MateWiki - Contribuciones del usuario [es]

Placa Plana (J52)

2025-12-11T10:28:05Z

Marco.moreno: /* Poster */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero). Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==

Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|600px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/DTjxPfKu654JJC_0Sbo5mw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h2f0186a480 Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T11:07:32Z

Marco.moreno: /* Gradiente Térmico */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero). Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==

Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|600px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T11:07:12Z

Marco.moreno: /* Gradiente Térmico */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero). Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==

Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|600px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T11:02:33Z

Marco.moreno: /* Gradiente Térmico */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero). Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==

Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|600px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T10:17:03Z

Marco.moreno: /* Masa total */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==

Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|600px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T08:26:00Z

Marco.moreno: /* Masa total */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
[[Archivo:dens.jpg|miniaturadeimagen|derecha|600px|Figura 10]]
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T08:25:32Z

Marco.moreno: /* Masa total */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
[[Archivo:dens.jpg|miniaturadeimagen|derecha|700px|Figura 10]]
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T08:24:28Z

Marco.moreno: /* Masa total */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
[[Archivo:dens.jpg|miniaturadeimagen|derecha|700px|Figura 10]]
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-10T08:21:30Z

Marco.moreno: /* Masa total */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
[[Archivo:dens.jpg|miniaturadeimagen|derecha|700px|Figura 10]]
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-09T09:06:13Z

Marco.moreno: /* Poster */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/UEhhMqJAQg3hJy6G-rBHUw/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h569bc8df1d Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-08T15:19:13Z

Marco.moreno: /* Tensor deformaciones */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==

Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/NCcR9uVESYva_Sh35Ob8-A/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h4be8379630 Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-08T15:18:08Z

Marco.moreno:

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/NCcR9uVESYva_Sh35Ob8-A/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h4be8379630 Poster Placa Plana Grupo 52]

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-07T23:37:24Z

Marco.moreno: /* Divergencia */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}
==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/NCcR9uVESYva_Sh35Ob8-A/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h4be8379630 Poster Placa Plana Grupo 52]

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-07T10:36:54Z

Marco.moreno:

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}
==Poster==
En el siguiente enlace podéis acceder al poster creado:
[https://www.canva.com/design/DAG6cq9cWK8/NCcR9uVESYva_Sh35Ob8-A/view?utm_content=DAG6cq9cWK8&utm_campaign=designshare&utm_medium=link2&utm_source=uniquelinks&utlId=h4be8379630 Poster Placa Plana Grupo 52]

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-03T10:29:19Z

Marco.moreno: /* Masa total */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-03T10:12:44Z

Marco.moreno:

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Campo de desplazamiento==
Se dibuja el '''campo de desplazamientos''' en los puntos del mallado del sólido. 
Como se puede observar en la imagen, si que '''hay puntos''' que se mantienen '''fijos'''.
Podemos ver que las funciones de desplazamiento tanto vertical son:
::<math> H(x,y)= \frac{xy}{20} </math> 
::<math> V(x,y)= \frac{-x^2}{20}</math> 
Podemos comprobar que los puntos que no '''sufren de desplazamiento''' son todos los valores
::<math>\frac{(x',y')}{H(x',y')}=0</math>, <math>\frac{(x',y')}{V(x',y')}=0 </math> 
que son todos aquellos en los que <math>x=0 </math>.
[[Archivo:Campodesplazamiento2.jpg|miniaturadeimagen|derecha|700px|Figura 5: Campo de Desplazamientos]]
<source lang="matlab">
clc; clear; close all;

% Definición del Dominio y Mallado
h = 0.1; % Muestreo
x = 0:h:4;
y= 0:h:2;
[X,Y]=meshgrid(x,y);

% Definición de la Placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara lógica
EnPlaca=Y>=f(X)&Y<=g(X);

% Cálculo del Campo de Desplazamientos u
U=(1/20).*X.*Y; % Componente horizontal
V=-(1/20).*X.^2; % Componente vertical

% Filtrar
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Gráfica y ajuste
figure('Name', 'Campo de Desplazamientos');
set(gcf,'Position',[100 100 800 500]);
hold on;
axis equal;
axis([-0.5 4.5 -1 2.5]);
grid on;
title('Campo de Desplazamientos');
xlabel('x'); ylabel('y');

% Dibujar el campo vectorial u
quiver(X,Y,U,V,0,'r', 'LineWidth',1,'MaxHeadSize', 0.5);

% Dibujar contorno de la placa como referencia
x_borde = linspace(0,4,200);
plot(x_borde,f(x_borde),'k','LineWidth',1);
plot(x_borde,g(x_borde),'k','LineWidth',1);
plot([0 0],[f(0) g(0)],'k','LineWidth',1); % Pared izquierda
plot([4 4],[f(4) g(4)],'k','LineWidth',1); % Pared derecha

% Puntos fijos
% Buscamos puntos donde el desplazamiento sea (0,0)
% Si x=0, entonces U=0 y V=0.Por lo que toda la pared izquierda (x=0) está fija.

plot(zeros(size(y)),y,'b.','MarkerSize',15); % Puntos azules
text(0.1,1,'\leftarrow Puntos Fijos (x=0)','Color','b','FontWeight','bold');

hold off;
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-03T09:57:46Z

Marco.moreno: /* Gradiente Térmico */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]

Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:19:17Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vec{F}=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:18:53Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>
::<math>(divσ)_{y}=(\frac{∂σ_{yx}}{∂_{x}}+\frac{∂σ_{yy}}{∂_{y}})=\frac{-1}{20}+\frac{1}{20}=0</math> 
 
<math>\vecF=−divσ=(0,0)</math>, Como se puede comprobar la '''fuerza resultante es cero''' en toda la placa.

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:15:29Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σ_{xx}}{∂_{x}}+\frac{∂σ_{xy}}{∂_{y}})=0+0=0</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:14:42Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 

:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

:4. Divergencia
::<math>(divσ)_{x}=(\frac{∂σxx}{∂x}+\frac{∂σxy}{∂y})=0+0=0</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:12:19Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>
:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::<math>σ_{xy}=σ_{yx}=\frac{-x}{20}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:11:40Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>
:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=\frac{y}{20}</math>
::Entonces: <math>σ_{xx}=\frac{3y}{20} , σ_{yy}=\frac{y}{20} </math>
::σ_{xy}=σ_{yx}=\frac{-x}{20}
::Tensor: <math>ε=\begin{pmatrix}
\frac{3y}{20} & \frac{-x}{20} \\
\frac{-x}{20} & \frac{y}{20} \\
\end{pmatrix}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:09:58Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>
:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math> , <math>trε=frac{y}{20}</math>
::Entonces: <math>σ_{xx}=frac{3y}{20} , σ_{yy}=frac{y}{20} </math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:07:33Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>
:3. Tensor de tensiones σ (λ = μ = 1)
::<math>σ_{ij}=λ(trε)δ_{ij}+2με_{ij}</math>
:

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:06:06Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>
:3. Tensor de tensiones σ\sigmaσ (λ = μ = 1)

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:05:32Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: <math>ε=\begin{pmatrix}
\frac{y}{20} & \frac{-x}{40} \\
\frac{-x}{40} & 0 \\
\end{pmatrix}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:01:14Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>
::Tensor: ε=(20y−40x−40x0)

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T11:00:13Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>
::Entonces: <math>ε_{xx}=\frac{y}{20},ε_{yy}=0</math>, <math>ε_{xy}=ε_{yx}=\frac{1}{2}(\frac{x}{20}-\frac{x}{10})=\frac{-x}{40}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:56:20Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{y}}{𝜕_{x}}=\frac{-x}{10},\frac{𝜕u_{y}}{𝜕_{y}}=0</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:55:33Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:55:02Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::::::<math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:54:53Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
::::::::<math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:54:41Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
::::::::::<math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:54:21Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>
:::::<math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:53:48Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
:1. Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
:2. Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>
::Calculamos derivadas: <math>\frac{𝜕u_{x}}{𝜕_{x}}=\frac{y}{20},\frac{𝜕u_{x}}{𝜕_{y}}=\frac{x}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:50:05Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#1 Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
#2 Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:49:40Z

Marco.moreno: /* Rotacional */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo:
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo:
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
#Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:49:19Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
#Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂u_{i}}{∂x_{j}}+\frac{∂u_{j}}{∂x_{i}})</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:48:58Z

Marco.moreno: /* Rotacional */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
#Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂ui}{∂xj}+\frac{∂uj}{∂xi})</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:48:24Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>
Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>
#Tensor de deformaciones <math>ε_{ij}=\frac{1}{2}(\frac{∂ui}{∂xj}+\frac{∂uj}{∂xi})</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:48:10Z

Marco.moreno: /* Rotacional */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes:

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>
Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación:

El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:47:07Z

Marco.moreno: /* Interpretación */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>
Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

Interpretación
El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:46:52Z

Marco.moreno: /* Máximos, mínimos y puntos relevantes */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

Máximos, mínimos y puntos relevantes

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>
Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

==Interpretación==
El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:46:37Z

Marco.moreno: /* Cálculo de |\nabla \times \vec{u}| */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

Cálculo de <math>|\nabla \times \vec{u}|</math>

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

==Máximos, mínimos y puntos relevantes==

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>
Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

==Interpretación==
El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]

Placa Plana (J52)

2025-12-02T10:45:14Z

Marco.moreno: /* Campo de Fuerzas */

{{ TrabajoED | Placa plana. Grupo 52 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] |Carlos Gallego García Arantxa Gonzales Mori Diego Pérez Fernández Diego Peña Ruiz Marco Moreno González }}

==Introducción==
Consideramos la sección longitudinal de una viga voladiza rectangular (en dimensión 2) que ocupa la región (Figura 1.) y que está fija en la pared vertical izquierda.
::<math> (𝑥, 𝑦) ∈ [0, 4] × [𝑓(𝑔), 𝑔(𝑥)],𝑓(𝑥) = \frac{x}{8},𝑔(𝑥) = 2 − \frac{x}{8} </math>

En ella vamos a suponer que tenemos definidas dos cantidades físicas: la temperatura 𝑇(𝑥, 𝑦) dada por
::<math> 𝑇(𝑥, 𝑦) = (1 + (𝑦 − 1)^2)(4 - x) </math>,
y los desplazamientos 𝑢⃗(𝑥, 𝑦) producidos por la acción de una fuerza determinada que no conocemos. De esta forma, si definimos <math> 𝑟⃗0 (𝑥, 𝑦) = 𝑥⃗𝑖 + 𝑦𝑗⃗ </math> el vector de posición de los puntos de la placa antes de la deformación, la posición de cada punto (𝑥, 𝑦) de la placa después de la
deformación viene dada por
::𝑟⃗d<math>(𝑥, 𝑦)</math> = 𝑟⃗0<math> (𝑥, 𝑦) + 𝑢⃗(𝑥, 𝑦)</math>.

Vamos a suponer que la fuerza aplicada sobre la placa ha provocado un desplazamiento de los puntos de la misma dado por el vector
::<math>𝑢⃗(𝜌, 𝜃) = −\frac{1}{20} 𝜌2cos 𝜃𝑒⃗𝜃</math>.

==Mallado del Solido==
Para dibujar el '''mallado''',habrá que parametrizar el sólido y tomar los ejes del el rectángulo <math>(x, y) ∈ [−1, 5] × [-1, 3]</math> ,además,como paso de muestreo: <math>h = \frac{1}{10}</math> para las variables <math>x</math> e <math>y</math>.

[[Archivo:malladoplanaplana3.jpeg|miniaturadeimagen|derecha|800px|Figura 1]]
<source lang="matlab">
clc; clear; close all;
%Datos
h = 0.1;
u = 0:h:4;
% Para la coordenada vertical, la altura máxima de la placa es 2 por lo que
% para mantener el paso h=0.1, necesitamos dividir esa altura en aprox 20 partes.
% y definimos un parámetro 's' que vaya de 0 a 1.
num_puntos_y=2/h;
s=linspace(0,1,num_puntos_y + 1);
%rejilla de parámetros
[U,S]=meshgrid(u,s);

% fronteras (borde inferior y superior)
f_u=U./8;
g_u=2-U./8;

%Calcular las coordenadas físicas X e Y
% X es U
X=U;
% Y es una interpolación entre el borde inferior y superior
Y=f_u+S.*(g_u-f_u);

%Dibujar el mallado
figure(1);
clf;
hold on;

%hacemos la rejilla y la configuramos
mesh(X,Y,zeros(size(X)),'EdgeColor',[0, 0.7, 0.7],'FaceColor','none');

%Dibujamos un contorno parecido a la imagen dada
plot(X(1,:),Y(1,:),'k','LineWidth',2)% Borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2)% Borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2)% Borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2)% Borde derecho

% Configuramos los ejes y el visionado
axis([-1 5 -1 3]);
xlabel('x');
ylabel('y');
title('Mallado de la placa plana');
view(2);
box on;
grid off;
axis equal
</source>

==Curvas de nivel==

Se dibujan las '''curvas de nivel''' de la temperatura y decidir en qué punto la temperatura es máxima. Se calcula el gradiente de la temperatura y se representa en la gráfica. 
Como se puede observar, los máximos se encuentran en los puntos: <math>(x,y)=(0,0)</math> y <math>(x,y)=(0,2)</math> 

El '''gradiente''' se calcula de la siguiente manera: 
::<math>∇T(x,y)=(\frac{∂T}{∂x},\frac{∂T}{∂y})=(−(1+(y−1)2),(4−x)⋅2(y−1)).</math>

Como se puede observar, el gradiente es ortogonal a las curvas de nivel.
[[Archivo:curvadenivel.jpeg|miniaturadeimagen|derecha|800px|Figura 2]]
<source lang="matlab">
clc; clear; close all;
% Definición del Mallado y Dominio
h=0.1; %Muestreo
x=0:h:4;
y=0:h:2;
[X,Y] = meshgrid(x, y);

% Funciones que definen la placa
f=@(x)x./8; % Límite inferior
g=@(x)2-x./8; % Límite superior

% Máscara para puntos dentro de la placa
EnPlaca=Y>=f(X)&Y< g(X);

% Definición de la Temperatura y el Gradiente
% Función T(x,y)
T=(1+(Y-1).^2).*(4-X);

% Aplicar máscara
T_plot=T;
T_plot(~EnPlaca)=NaN;

% Cálculo numérico del gradiente para los vectores (o usar fórmula exacta)
% Usamos la fórmula exacta derivada arriba para mayor precisión
U=-(1+(Y-1).^2); % Componente x del gradiente
V=2.*(Y-1).*(4-X); % Componente y del gradiente

% Solo mostramos vectores dentro de la placa
U(~EnPlaca)=NaN;
V(~EnPlaca)=NaN;

% Generación de la Gráfica
figure(1);
clf; % Limpiar figura
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
title({'Isotermas y Gradiente \nabla T', 'T(x,y) = (1+(y-1)^2)(4-x)'});
xlabel('x'); ylabel('y');

% Mapa de calor de fondo
[C_fill, h_fill] = contourf(X, Y, T_plot, 20, 'LineStyle', 'none');
colormap(jet); % Mapa de colores tipo jet
cb=colorbar;
ylabel(cb,'Temperatura T');

% Curvas de nivel
[C, h_cont]=contour(X,Y,T_plot,10,'k','LineWidth',1.5);
clabel(C,h_cont,'FontSize',9,'Color','k','FontWeight','bold');

% Campo Vectorial (Gradiente)
% Submuestreamos cada 3 puntos para que no se vea una mancha de flechas
step=3;
quiver(X(1:step:end,1:step:end),Y(1:step:end, 1:step:end), ...
U(1:step:end,1:step:end),V(1:step:end,1:step:end), ...
1.2,'k','LineWidth',1); % '1.2' es el factor de escala de las flechas

% Dibujar bordes de la placa
plot(x,f(x),'k-','LineWidth',2); % Borde inferior
plot(x,g(x),'k-','LineWidth',2); % Borde superior
plot([0 0],[f(0) g(0)],'k-','LineWidth',2); % Pared izquierda
plot([4 4],[f(4) g(4)],'k-','LineWidth',2); % Pared derecha

% Señalar Máximo
plot(0,0,'rp','MarkerSize',12,'MarkerFaceColor','r');
plot(0,2,'rp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1,0,'Max T','Color','white','FontWeight','bold');

hold off;
</source>

==Energía calorífica(LEY DE FOURIER)==

De acuerdo con la '''ley de Fourier''', la energía calorífica <math>\vec{Q}</math> se describe mediante la fórmula 
:: <math>\vec{Q} = −𝜅∇T </math> 
donde 𝜅 es la constante de conductividad térmica de la placa; supondremos 𝜅 = 1. . Como 𝜅 es igual a la unidad podemos ver en la representación como
:: <math>\vec{Q} = −∇T </math> 
[[Archivo:fourier1.jpg|miniaturadeimagen|derecha|800px|Figura 3: Flujo de Calor(Ley de Fourier)]]
<source lang="matlab">
clc; clear; close all;

% Definición del Escenario
h=0.1;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;
g=2-X./8;
EnPlaca=Y>=f&Y<=g; % Máscara

% Cálculos y Gradiente de T
Grad_x=-(1+(Y-1).^2);
Grad_y=2.*(Y-1).*(4-X);

% Flujo de Calor Q (Ley de Fourier)
k=1; % Constante de conductividad
Qx=-k.*Grad_x;
Qy=-k.*Grad_y;

% Borrar vectores fuera de la placa
Qx(~EnPlaca)=NaN;
Qy(~EnPlaca)=NaN;

% Visualización
figure('Name','Flujo de Calor (Ley de Fourier)');
hold on;
axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Flujo de Calor', 'El calor viaja desde lo caliente a lo frío'});
xlabel('X'); ylabel('Y');

% Temperatura de fondo
T=(1+(Y-1).^2).*(4-X);
T(~EnPlaca)=NaN;
contourf(X,Y,T,15,'LineStyle','none','FaceAlpha',0.5);
colormap(jet);c=colorbar;ylabel(c,'Temperatura');

% Dibujar el Campo Vectorial Q
% Usamos 'step' para no pintar todas las flechas y que se vea limpio
step=3;
idx=1:step:size(X, 1);
idy=1:step:size(X, 2);

quiver(X(idx,idy),Y(idx,idy),Qx(idx,idy),Qy(idx,idy),1.5,'k','LineWidth',0.75);

% Bordes
x_b=linspace(0,4, 200);
plot(x_b,f(x_b),'k','LineWidth',2);
plot(x_b,g(x_b),'k','LineWidth',2);
plot([0 0],[0 2],'k','LineWidth',2);
plot([4 4],[0.5 1.5],'k','LineWidth',2);

% Origen del flujo
plot(0,0,'ko','MarkerFaceColor','w');
plot(0,2,'ko','MarkerFaceColor','w');

hold off;
</source>

==Gradiente Térmico==
El punto de máxima variación térmica corresponde al punto donde el '''gradiente es máximo'''' (En la practica para hallar este valor igualaremos la derivada del gradiente a cero).Mientras que la '''variación térmica''' sigue la '''dirección de dicho gradiente''', el '''flujo de calor''' más intenso lo hace en '''sentido contrario''', es decir, hacia donde baja la temperatura.

Lo primero que haremos será llamar a una función:
:: <math>\ G(x,y)=||∇T||^2 </math> 
:: <math>\ G(x,y)=((1+(y-1)^2)^2+(2(y-1)(4-x))^2 </math> 
:: <math>\ G(x,y)=((y^2-2Y+2)^2+4(y-1)^2(4-x)^2 </math> 
cuando tengamos la función <math>\ G(x,y)=||∇T||^2 </math> 
para maximizarla derivaremos la función y la igualaremos a 0 simultáneamente
::<math>(\frac{∂G}{∂x})= -8(y-1)^2(4-x)=0</math>
::<math>(\frac{∂G}{∂y})=4(y-1)(1+(y-1)^2+2(4-x)^2)=0 </math>
tras hacer este sistema de ecuaciones dictamínanos que los mínimos se encuentran sobre la recta
::<math> y=1 </math> 
Como no aparecen máximos aislados, los máximos deben buscarse en la frontera del dominio:

::Borde izquierdo (recta <math> x=0 </math>)
::Borde derecho (recta <math> x=4 </math>)
::Curva superior (<math> y=x^8 </math>)
::Curva superior (<math> y=2-x^8 </math>)

Tras comprobar los limites del recinto vemos que los máximos de la función del gradiente térmico se encuentran en el borde izquierdo de este,(recta <math> x=0 </math>)
respecto a la coordenadas, los máximos se encuentran en <math>y=0 </math> y en <math>y=2 </math>
::Los puntos donde la variación de temperatura es máxima son:

'''P(1)''': x=0.00, y=0.00. ''Dirección del vector'': [-2.00, -8.00]

'''P(2)''': x=0.00, y=2.00. ''Dirección del vector'': [-2.00, 8.00]
Ahora calcularemos la máxima variación térmica que se traduce en el módulo del gradiente en los puntos '''P(1)''' y '''P(2)''':
Como el valor de la norma del gradiente es la misma para P(1) y P(2), solo calcularemos uno de los puntos, en este caso calcularemos p(1)=(0,0)
calculo de <math>\||∇T(0,0)||</math>
::<math>∇T(0,0)=(-(1+(0-1)^2,2(0-1)(4-0))=(-2,-8)</math> 
::<math>\||∇T(0,0)||=\sqrt{(64+4)}=2\sqrt{17}\approx 8.246</math> 

[[Archivo:maxvart.jpg|miniaturadeimagen|derecha|800px|Figura 4:Máxima Variación de T]]
<source lang="matlab">
clc; clear; close all;

h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);
f=X./8;g=2-X./8;
EnPlaca=Y>=f&Y<=g;

% Cálculos de Gradiente y Norma
Tx=-(1+(Y-1).^2);
Ty=2.*(Y-1).*(4-X);

% Norma del Gradiente
NormaGrad=sqrt(Tx.^2+Ty.^2);
NormaGrad(~EnPlaca)=0;

% Buscar el Máximo
max_val=max(NormaGrad(:));
[filas,cols]=find(NormaGrad==max_val);

% Coordenadas de los puntos máximos
x_max=X(filas,cols);
y_max=Y(filas,cols);

% Componentes del vector dirección en esos puntos
u_dir=Tx(filas,cols);
v_dir=Ty(filas,cols);

% Visualización
figure('Name','Máxima Variación de T');
hold on;axis equal;axis([-0.5 4.5 -0.5 2.5]);grid on;
title({'Puntos de Máxima Variación de Temperatura', '(Color = Magnitud del Gradiente T)'});
xlabel('x'); ylabel('y');

% Mapa de calor
NormaGrad(~EnPlaca)=NaN;
contourf(X,Y,NormaGrad,20,'LineStyle','none');
colormap(jet);colorbar;

% Contorno
plot([0 4 4 0 0],[0 0.5 1.5 2 0],'k','LineWidth',1.5);

% Puntos rojos y dirección
plot(x_max, y_max,'ro','MarkerSize',7.5,'MarkerFaceColor','r');

% Flechas de dirección
quiver(x_max,y_max,u_dir,v_dir,0.5,'k','LineWidth',2,'MaxHeadSize',0.5);

% Resultados
fprintf('La variación máxima es %.2f\n', max_val);
fprintf('Ocurre en los puntos:\n');
for i=1:length(x_max)
fprintf('P(%d): x=%.2f, y=%.2f. Dirección del vector: [%.2f, %.2f]\n',i,x_max(i),y_max(i),u_dir(i),v_dir(i));
end
</source>

==Desplazamientos==
Se dibuja el sólido antes y después del '''desplazamiento''' dado por el campo de vectores <math>𝑢⃗</math>.
[[Archivo:comp11.jpg|miniaturadeimagen|derecha|800px|Figura 6:Comparación Antes/Después]]
<source lang="matlab">
clc; clear; close all;

% Generación de la Malla
h=0.2;
u=0:h:4;
s=linspace(0,1,11);
[U,S]=meshgrid(u,s);

% Coordenadas Originales
f_x=U./8;
g_x=2-U./8;
X0=U;
Y0=f_x+S.*(g_x-f_x);
Z0=zeros(size(X0));

% Cálculo de la Deformación y Campo de desplazamientos u(x,y)
Ux=(X0.*Y0)./20;
Uy=-(X0.^2)./20;

% Coordenadas Deformadas
Xd=X0+Ux;
Yd=Y0+Uy;

% Visualización
figure('Name','Comparación Antes/Después','Color','w');

% ANTES
subplot(1,2,1);
mesh(X0,Y0,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0],[0 2],'k','LineWidth',3); % Pared fija
title('Antes del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

% DESPUÉS
subplot(1,2,2);
mesh(Xd,Yd,Z0,'EdgeColor',[0 0.7 0.9],'FaceColor','none');
hold on;
plot([0 0], [0 2],'k','LineWidth',3);
title('Después del desplazamiento');
xlabel('X'); ylabel('Y');
axis equal; axis([-0.5 4.5 -1.5 2.5]); grid on;
view(2);

</source>

==Divergencia==
La '''divergencia''' <math> (∇⋅𝑢⃗)</math> mide la variación de volumen local.
La divergencia del campo de desplazamiento es:

<math> u_x=\frac{1}{20}xy,\qquad u_y=-\frac{1}{20}x^2 </math>

Entonces:

<math> \nabla\cdot\vec{u} =\frac{\partial u_x}{\partial x}+\frac{\partial u_y}{\partial y} =\frac{\partial}{\partial x}\left(\frac{1}{20}xy\right) +\frac{\partial}{\partial y}\left(-\frac{1}{20}x^2\right) =\frac{y}{20} </math>

La divergencia depende únicamente de la coordenada <math>y</math>.

La placa cumple: <math> 0\le x\le 4,\qquad \frac{x}{8}\le y\le 2-\frac{x}{8} </math>

Máximo: Para maximizar <math>\nabla\cdot\vec{u}=\frac{y}{20}</math> basta maximizar <math>y</math>.

El máximo valor de <math>y</math> en la región es: <math>y_{\max}=2</math> (en <math>x=0</math>)

Por tanto: <math> (\nabla\cdot\vec{u})_{\max}=\frac{2}{20}=0.1 </math>

El máximo se alcanza en: <math>(0,2)</math>

Mínimo: El valor mínimo permitido de <math>y</math> es: <math>y_{\min}=0</math> (también en <math>x=0</math>)

Entonces: <math> (\nabla\cdot\vec{u})_{\min}=0 </math>

El mínimo ocurre en: <math>(0,0)</math>

Puntos donde la divergencia es nula

La divergencia se anula cuando: <math> \frac{y}{20}=0 \quad \Rightarrow \quad y=0 </math>

Dentro de la placa esto solo sucede en: <math>(0,0)</math>

El cual indica que la placa sufre una expansión positiva que aumenta linealmente con la altura debido al estiramiento de las fibras superiores.

En la gráfica,se puede apreciar en las franjas de color:
En '''azul''' esta la base,donde el '''volumen no cambia''',degradándose progresivamente hacia el '''rojo''' intenso del borde superior donde se encuentra el '''punto de máxima expansión''', independientemente de la posición horizontal x.
[[Archivo:divergenciaplaca.jpg|miniaturadeimagen|derecha|800px|Figura 7]]
<source lang="matlab">
clc; clear; close all;
% Definir Malla y Placa
h=0.05;
[X,Y]=meshgrid(0:h:4, 0:h:2);
f=X./8;g=2-X./8; % Límites
EnPlaca=Y>=f&Y<=g; % Máscara lógica

% Cálculo de la Divergencia (div=y/20)
Div=Y./20;
Div(~EnPlaca)=NaN;

% Visualización
figure('Name','Divergencia');clf;hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');
[C, h_cont]=contourf(X, Y, Div, 20,'LineStyle','none');
colormap(jet);
c=colorbar;ylabel(c,'Valor de Divergencia');

% Dibujar bordes negros
x_b = linspace(0, 4, 200);
plot(x_b, x_b./8,'k','LineWidth',1);
plot(x_b, 2 - x_b./8,'k','LineWidth',1);
plot([0 0],[0 2],'k','LineWidth',1);
plot([4 4],[0.5 1.5],'k','LineWidth',1);

% Señalar puntos clave
% Máxima: Ocurre en y=2 y x=0
plot(0,2,'kp','MarkerSize',12,'MarkerFaceColor','r');
text(0.1, 2.1,'Max Expansión','FontWeight','bold');

% Nula: Ocurre en y=0 y x=0
plot(0,0,'kp','MarkerSize',12,'MarkerFaceColor','b');
text(0.1,-0.1,'Divergencia Nula','FontWeight','bold');
hold off;
</source>

==Rotacional==

Se calcula el '''rotacional''' <math>(|∇ × 𝑢⃗|)</math> en todos los puntos del sólido. 
Los '''puntos más alejados del origen''' y alineados con el eje x sufren '''mayor rotacional'''.

==Cálculo de <math>|\nabla \times \vec{u}|</math>==

Dado el campo de desplazamientos
<math>u_x = \frac{1}{20}xy,\qquad u_y = -\frac{1}{20}x^2</math>

el rotacional en 2D solo tiene componente en la dirección <math>\vec{k}</math>:

<math> (\nabla \times \vec{u})_z = \frac{\partial u_y}{\partial x} - \frac{\partial u_x}{\partial y}. </math>

Calculamos las derivadas:

<math> \frac{\partial u_y}{\partial x} = -\frac{x}{10}, \qquad \frac{\partial u_x}{\partial y} = \frac{x}{20}. </math>

Entonces,

<math> (\nabla \times \vec{u})_z = -\frac{x}{10} - \frac{x}{20} = -\frac{3x}{20}. </math>

La magnitud viene dada por:

<math> |\nabla \times \vec{u}| = \left| -\frac{3x}{20} \right| = \frac{3x}{20}. </math>

==Máximos, mínimos y puntos relevantes==

Mínimo
El mínimo valor se obtiene cuando <math>x = 0</math>:
<math>|\nabla \times \vec{u}|_{\min} = 0.</math>
Esto ocurre en todo el borde izquierdo del sólido (el empotramiento).

Máximo
El máximo se alcanza cuando <math>x = 4</math>:
<math>|\nabla \times \vec{u}|_{\max} = \frac{3\cdot 4}{20} = 0.6.</math>
Esto sucede en el borde derecho del sólido (la parte libre).

==Interpretación==
El rotacional crece linealmente con <math>x</math>.
Los puntos cercanos al empotramiento (<math>x=0</math>) no giran, mientras que los puntos en el borde derecho (<math>x=4</math>) experimentan la mayor rotación.

[[Archivo:rot33.jpg|miniaturadeimagen|derecha|600px|Figura 1]]
<source lang="matlab">
clc; clear; close all;

% Definición del Mallado
h=0.05;
[X,Y] =meshgrid(0:h:4, 0:h:2);
Condition =(Y >= X./8) & (Y <= 2 - X./8);

% Cálculo del Rotacional
% Fórmula derivada anteriormente: Rot_z = -3x/20
% Tomamos el valor absoluto (módulo) para dibujar la magnitud
Rot_Modulo = abs(-(3 .* X) ./ 20);

% Filtrado
Rot_Modulo(~Condition) = NaN; %(Borrar lo de fuera)

% Visualización 3D y 2D)
figure('Name', 'Rotacional', 'Position', [100, 50, 600, 800]);

% VISTA 3D
subplot(2, 1, 1);
surf(X, Y, Rot_Modulo);
shading interp;
colormap(jet);
colorbar;
axis tight;
grid on;
view(-30, 45);
title('Vista 3D');
zlabel('Magnitud');
xlabel('x'); ylabel('y');
text(0, 1, 0.6, 'Sube como una rampa', 'Color', 'k');

% VISTA 2D
subplot(2, 1, 2);
contourf(X, Y, Rot_Modulo, 20, 'LineStyle', 'none');
hold on;
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k', 'LineWidth', 2); % Bordes
colormap(jet);
colorbar;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Vista 2D');
xlabel('x'); ylabel('y');

% Señalar el máximo en 2D
plot([4 4], [0.5 1.5], 'r', 'LineWidth', 3);
text(2.5, 2, 'Mayor giro en x=4', 'FontWeight', 'bold');

hold off;
</source>

==Tensor deformaciones==
/math>
Se define <math>𝜖(𝑢⃗) = \frac{1}{2}(∇𝑢⃗ + ∇𝑢⃗ </math> t <math>)</math>, la parte simétrica del tensor gradiente de <math>𝑢⃗</math>, conocido como '''tensor de deformaciones'''. En un medio elástico lineal, isótropo y homogéneo los desplazamientos permiten escribir el tensor de tensiones 𝜎 a través de la fórmula <math>𝜎 = 𝜆∇ ⋅ 𝑢⃗ I + 2𝜇𝜖</math>,
donde <math>I</math> es el tensor identidad en el conjunto de vectores libres del espacio <math>ℝ^3, 𝜆, 𝜇</math> son conocidos como '''coeficientes de Lamé''', que dependen de las propiedades elásticas de cada material. 
Tomando <math>𝜆 = 𝜇 = 1</math>, se dibujan las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i} ⋅𝜎⋅ \vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j} ⋅𝜎⋅ \vec{j}</math>, y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k} ⋅𝜎⋅ \vec{k}</math> (se dibujan las que no son nulas).

[[Archivo:contorno.jpg|miniaturadeimagen|derecha|800px|Figura 9]]
<source lang="matlab">

clc; clear; close all;

% Geometría de la placa
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);% parámetro vertical [0,1]

[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;

X = U;
Y = f + S.*(g - f);

% Campo de desplazamientos aplicado
% Desplazamiento dado en polares: u~(rho,theta) = -(1/20) rho^2 cos(theta) e_theta
% Convertido a cartesianas: u = [xy/20, -x^2/20]
u = (X.*Y)/20; % componente en x
v = -(X.^2)/20; % componente en y
% w = 0 (desplazamientos planos)

% Derivadas analíticas
ux_x = Y/20;
ux_y = X/20;
vy_x = -(X/10);
vy_y = zeros(size(X));

div_u = ux_x + vy_y; % divergencia = y/20

% Tensor de deformaciones
eps_xx = ux_x;
eps_yy = vy_y;
eps_xy = 0.5*(ux_y + vy_x);

% Tensiones
lambda = 1; mu = 1;
sigma_xx = lambda*div_u + 2*mu*eps_xx; % = 3y/20
sigma_yy = lambda*div_u + 2*mu*eps_yy; % = y/20
sigma_zz = lambda*div_u; % = y/20 (eps_zz=0)
sigma_xy = 2*mu*eps_xy; % = -x/20
sigma_yx = sigma_xy; % simétrico
sigma_xz = zeros(size(X)); % no hay variación en z
sigma_zx = zeros(size(X)); % idem

% Tensión tangencial respecto al plano ortogonal a i
% tau_i = |sigma*i - (i·sigma·i) i| = sqrt( sigma_yx^2 + sigma_zx^2 )
tau_i = abs(sigma_yx); % = | -x/20 |

% Gráficos

cm = turbo; % o 'jet'
lw = 1.2;

% Mallado y contornos de la placa
figure('Name','Mallado de la placa','Color','w');
mesh(X,Y,zeros(size(X)),'EdgeColor',[0,0.6,0.7],'FaceColor','none'); hold on;
plot(X(1,:),Y(1,:),'k','LineWidth',2); % borde inferior
plot(X(end,:),Y(end,:),'k','LineWidth',2); % borde superior
plot(X(:,1),Y(:,1),'k','LineWidth',2); % borde izquierdo (pared)
plot(X(:,end),Y(:,end),'k','LineWidth',2); % borde derecho
axis([-0.5 4.5 -0.5 2.5]); axis equal; grid on; box on;
xlabel('x'); ylabel('y'); title('Mallado y contorno de la placa');

% Tensiones normales
figure('Name','Tensiones normales','Color','w');
tiledlayout(1,3,'Padding','compact','TileSpacing','compact');

nexttile;
surf(X,Y,sigma_xx); shading interp; colormap(cm); colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{xx}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_yy); shading interp; colormap(cm); colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{yy}');
axis tight; daspect([1 1 0.35]); view(45,30);

nexttile;
surf(X,Y,sigma_zz); shading interp; colormap(cm); colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y'); zlabel('\sigma_{zz}');
axis tight; daspect([1 1 0.35]); view(45,30);
sgtitle('Distribución de tensiones normales (\lambda=\mu=1)','FontWeight','bold');

% Tensión tangencial respecto a i
figure('Name','Tension tangencial respecto a i','Color','w');
surf(X,Y,tau_i); shading interp; colormap(cm); colorbar;
title('\tau_{i} = |\sigma_{xy}|'); xlabel('x'); ylabel('y'); zlabel('\tau_{i}');
axis tight; daspect([1 1 0.35]); view(45,30); grid on;

% Mmapas en planta
figure('Name','Contornos 2D de tensiones','Color','w');
tiledlayout(1,4,'Padding','compact','TileSpacing','compact');

nexttile; contourf(X,Y,sigma_xx,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{xx}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_yy,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{yy}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,sigma_zz,20,'LineColor','none'); axis equal tight; colorbar;
title('\sigma_{zz}'); xlabel('x'); ylabel('y');

nexttile; contourf(X,Y,tau_i,20,'LineColor','none'); axis equal tight; colorbar;
title('\tau_{i}'); xlabel('x'); ylabel('y');
</source>

==Tensiones tangenciales==
Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>, es decir |𝜎 ⋅ <math>\vec{i}</math>− (<math>\vec{i}</math>⋅ 𝜎 ⋅<math>\vec{i}</math>)<math>\vec{i}</math>|. Se dibujan solo las no nulas.
[[Archivo:Tangenciales.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">
% Definimos la tensión tangencial en el plano ortogonal al eje i (X), que es tau = [0, sigma_yx, 0].
Tau_x = zeros(size(sigma_xy)); % (debe ser nula).
Tau_y = sigma_yx;

% La magnitud (tau_i_magnitude) se mantiene aquí, pero no se utiliza en el gráfico final.
tau_i_magnitude = abs(sigma_yx);

% Creamos la figura y configuración inicial
figure('Name','Tensión Tangencial ','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Tensiones tangenciales respecto al plano ortogonal a i');
xlabel('x');
ylabel('y');

% El vector tau es vertical: (0,-x/20), según los cálculos del Ejercicio 9.
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);

% Usar el comando quiver para dibujar las flechas de tensión.
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Tau_x(idx_y, idx_x),Tau_y(idx_y, idx_x),1.5,'r', 'LineWidth', 1.2);
% Cortorno de la placa
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);

hold off;

</source>

==Tensión de Von Mises==

La tensión de Von Mises de define como 
<math> σ_{VM} = \sqrt{\frac{(σ_{1}-σ_{2})^2 + (σ_{2}-σ_{3})^2 + (σ_{3}-σ_{1})^2}{2}} </math>. 
Esta fórmula combina las diferencias entre las tensiones principales y mide el esfuerzo equivalente que experimenta el material.

[[Archivo:vonn.jpg|miniaturadeimagen|derecha|700px|Figura 11]]
<source lang="matlab">

clc; clear; close all;

% Malla
h = 0.1;
[x, y] = meshgrid(0:h:4, 0:h:2); % ojo: x -> columnas, y -> filas
X = x; Y = y;

% Bordes de la placa
f = X./8;
g = 2 - X./8;
EnPlaca = (Y >= f) & (Y <= g);

% Definición del campo de desplazamientos en cartesianas
ux=(1/20).*X.*Y;
uy=-(1/20).*X.^2;

% Derivadas analíticas:
% ux_x=d(u_x)/dx=y/20
% ux_y=d(u_x)/dy=x/20
% uy_x=d(u_y)/dx=-x/10
% uy_y=d(u_y)/dy 0
ux_x=Y./20;
ux_y=X./20;
uy_x=-X./10;
uy_y=zeros(size(X));

% Divergencia (útil para sigma)
divU=ux_x+uy_y;

% Tensor de deformaciones simétrico
% epsilon = 1/2(grad u + grad u^T)
% epsilon_xx = ux_x
% epsilon_yy = uy_y
% epsilon_xy = 1/2*(ux_y + uy_x)
eps_xx = ux_x;
eps_yy = uy_y;
eps_xy = 0.5*(ux_y + uy_x);

% Para el caso 3D consideramos eps_zz = 0
eps_zz = zeros(size(X));

% Coeficientes de Lamé
lambda=1;
mu=1;

% Construcción del tensor de tensiones
%sigma = lambda*div(u)*I + 2*mu*eps
sigma_xx = lambda.*divU + 2*mu.*eps_xx;
sigma_yy = lambda.*divU + 2*mu.*eps_yy;
sigma_zz = lambda.*divU + 2*mu.*eps_zz;
sigma_xy = 2*mu.*eps_xy; % = sigma_yx

% Von Mises y matriz para autovalores
VM = NaN(size(X));
S1 = NaN(size(X)); S2 = NaN(size(X)); S3 = NaN(size(X));

% Loop sobre puntos dentro de la placa para calcular autovalores
[idx_i,idx_j]=find(EnPlaca);
npts=numel(idx_i);

for k = 1:npts
i = idx_i(k); j = idx_j(k); % i: fila (y index), j: columna (x index)
% construir sigma 3x3 en ese punto
S = [sigma_xx(i,j), sigma_xy(i,j), 0;sigma_xy(i,j), sigma_yy(i,j),0;0,0,sigma_zz(i,j)];
e = eig(S);
% ordenar autovalores (no estrictamente necesario, pero ordeno descendente)
e = sort(e,'descend');
s1 = e(1); s2 = e(2); s3 = e(3);
% tensión de Von Mises (fórmula)
sigmaVM = sqrt( ((s1-s2).^2 + (s2-s3).^2 + (s3-s1).^2) / 2 );
VM(i,j) = sigmaVM;
S1(i,j) = s1; S2(i,j) = s2; S3(i,j) = s3;
end

VM(~EnPlaca) = NaN;
% Buscar máximo de Von Mises dentro de la placa
[maxVM, indMax] = max(VM(:));
[rowMax, colMax] = ind2sub(size(VM), indMax);
xMax = X(rowMax, colMax);
yMax = Y(rowMax, colMax);

% Visualización
figure('Name','Tensión de Von Mises','Color','w'); clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Tensión de Von Mises \sigma_{VM}');
xlabel('x'); ylabel('y');

% Contourf del campo VM
numLevels = 30;
[C, hC] = contourf(X, Y, VM, numLevels, 'LineStyle','none');
colormap(jet);
c = colorbar; ylabel(c, '\sigma_{VM}');
% Bordes de la placa
xb = linspace(0,4,200);
plot(xb, xb./8, 'k-', 'LineWidth', 1.5);
plot(xb, 2 - xb./8, 'k-', 'LineWidth', 1.5);
plot([0 0], [0 2], 'k-', 'LineWidth', 1.5);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 1.5);

% Punto de máxima tensión de Von Mises
plot(xMax, yMax, 'rp', 'MarkerSize', 14, 'MarkerFaceColor', 'r');
text(xMax+0.08, yMax+0.08, sprintf('Máx VM = %.3g', maxVM), 'FontWeight','bold','Color','r');

% Mejora estética
set(gcf,'Color','w');
shading interp;

hold off;

% Información
fprintf('Máximo Von Mises = %.6g en (x,y) = (%.4g, %.4g)\n', maxVM, xMax, yMax);
</source>

==Campo de Fuerzas==

El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal <math>\vec{F}= − div 𝜎</math>, donde <math>div 𝜎</math> es la divergencia de un campo tensorial, que en coordenadas cartesiana se define como <math>div 𝜎 = (div 𝜎)_{1}\vec{i} + (div 𝜎)_{2}\vec{j}+ (div 𝜎)_{3}\vec{k}, (div 𝜎)\vec{i} =3</math> 
<math>\sum_{j=1}^3 = \frac{𝜕𝜎_{ij}}{𝜕_{xj}}</math>. 
Resuelvo: 
#Desplazamiento en coordenadas cartesianas 
::Tenemos: <math>u⃗(ρ,θ)=-\frac{1}{20}\rho^2 \cos\theta\,e_{θ}</math>
::Convertimos a cartesianas: <math>ρ=\sqrt{x^2 + y^2}, \quad \theta = \arctan\left(\frac{y}{x}\right)</math>
::El vector <math>\vec{e}_\theta = (-\sin\theta, \cos\theta)</math>. Entonces: <math> u⃗_{x}=\frac{1}{20}\rho^2 \cos\theta\sin\theta </math>, <math> u⃗_{y}=-\frac{1}{20}\rho^2 \cos^2\theta</math>
::Usamos: <math>sinθ=\frac ρy,cosθ=\frac ρx</math>. Entonces: <math>u⃗_{x}=\frac{1}{20}\rho^2\frac ρx\frac ρy= \frac{xy}{20}</math>, <math>u⃗_{y}=\frac{1}{20}\rho^2\frac{x^2}{\rho^2}=\frac{-x^2}{20}</math>

[[Archivo:Campoofuerzas.png|miniaturadeimagen|derecha|700px|Figura 10]]
<source lang="matlab">

% Definición del paso de muestreo (h) y el vector de coordenadas X.
h = 0.1;
x = 0:h:4;
num_puntos_y = round(2/h);
s = linspace(0,1,num_puntos_y+1);

% Generación del mallado físico (X, Y) dentro de la geometría trapezoidal.
[U,S] = meshgrid(x,s);
f = U./8;
g = 2 - U./8;
X = U;
Y = f + S.*(g - f);

% Creación de la máscara lógica para identificar los puntos interiores de la placa.
mask = (Y >= X/8) & (Y <= 2 - X./8);

% CAMPO DE FUERZA F
% Cálculo analítico: F = -div(sigma) resulta en F = [0, 0].
% Inicializa la componente horizontal Fx a cero.
Fx = zeros(size(X));

% Inicializa la componente vertical Fy a cero.
Fy = zeros(size(X));

% Aplica la máscara: los puntos fuera de la placa se establecen a NaN (no se dibujan).
Fx(~mask) = NaN;
Fy(~mask) = NaN;

% Configuración inicial de la figura y los ejes para la visualización.
figure('Name','Campo de Fuerzas F','Color','w');
hold on;
axis equal;
box on;
grid on;
axis([-0.5 4.5 -0.5 2.5]);
title('Campo de Fuerzas Volumétricas ');
xlabel('x');
ylabel('y');

% DIBUJO DEL CAMPO VECTORIAL
step = 3;
idx_x = 1:step:size(X,2);
idx_y = 1:step:size(X,1);
quiver(X(idx_y, idx_x), Y(idx_y, idx_x),Fx(idx_y, idx_x),Fy(idx_y, idx_x),0.5,'b', 'LineWidth', 1.2);

%Resultado analítico de F=0.
text(2, 1, '¡El campo de fuerzas nulo!','HorizontalAlignment', 'center', 'FontSize', 14, 'Color', [0.5 0 0], 'FontWeight', 'bold');
text(2, 0.7, 'El equilibrio se satisface en el interior de la placa.','HorizontalAlignment', 'center', 'FontSize', 10, 'Color', [0.5 0 0]);

% Dibuja las líneas que delimitan el contorno de la placa.
plot(x, x/8, 'k-', 'LineWidth', 2);
plot(x, 2 - x/8, 'k-', 'LineWidth', 2);
plot([0 0], [0 2], 'k-', 'LineWidth', 2);
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2);
hold off;
</source>

==Masa total==
Supongamos que la densidad de la placa es <math>𝑑(𝑥, 𝑦) = (4 − 𝑥)|𝑦|</math>. Se calcula la masa total aproximando la integral correspondiente numéricamente 
La región en la que trabajamos es <math> x∈[0,4], y∈[\frac8x, 2−\frac8x] </math>. Por lo tanto, la integral para la masa es:
<math>M=\int_{0}^{4} \int_{\frac{x}{8}}^{2 - \frac{x}{8}} (4 - x)y \, dy \, dx</math>. Resolviendo: 
:Paso 1: Integral interna
:::<math>\int_{\frac{x}{8}}^{2 - \frac{x}{8}} y \, dy = \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right]</math>
:Entonces la integral completa es:
:::<math>M=\int_{0}^{4} (4 - x) \cdot \frac{1}{2}\left[(2 - \frac{x}{8})^2 - (\frac{x}{8})^2\right] dx</math> 
:Resolviendo queda que <math>M=13,33</math> (unidades de masa)

[[Archivo:dens.jpg|miniaturadeimagen|derecha|800px|Figura 10]]
<source lang="matlab">
clc; clear; close all;
% Mallado
h=0.05;
[X,Y]=meshgrid(0:h:4,0:h:2);

% Forma de la placa
Condition=(Y>=X./8)&(Y<=2-X./8);

% Definición de la Densidad : d(x,y)=(4-x)*|y|
Densidad=(4-X).*abs(Y);

% Filtrado para la Gráfica
Densidad(~Condition)=NaN;

% Visualización 3D
figure('Name','Densidad', 'Color','w');

% Superficie 3D
surf(X,Y,Densidad);

% Configuración
shading interp; % Elimina las líneas negras para que se vea suave
colormap(jet); % Mapa de colores (De azul a rojo)
colorbar; % Barra de referencia
caxis([0 8]); % Fija la escala de colores

% Etiquetas y Título
title({'Densidad'},'FontSize',13);
xlabel('Eje X','FontWeight','bold');
ylabel('Eje Y','FontWeight','bold');
zlabel('Densidad (kg/m^2)','FontWeight','bold');

% Ajustes
axis tight; % Ajusta los ejes al contenido
view(-45, 30); % Ángulo de vista
grid on;
box on;

% Proyección de sombra en el suelo
hold on;
% Dibujamos el contorno plano abajo del todo (en z=0) para referencia
contour(X,Y,Densidad,20,'z','Offset',0);
hold off;
</source>

==Ejemplos de uso en la ingeniería ==

Una viga en voladizo tiene grandes uso debido a su forma, además de ser muy útil por su funcionalidad. Estas vigas tienen un gran abanico de usos como:
* Usos arquitectónicos → balcones y terrazas, cubiertas de entradas y marquesinas...
* Maquinarias → Brazos de grúas o en palas de aerogeneradores...
* En la ingeniería → Puentes en voladizo,palas de un aereogenerador...

==Bibliografía==

Para realizar el trabajo nos hemos apoyado en:
* Matlab (Aplicación informática para representar las gráficas y dibujos)
* Apuntes de clase y los proporcionados por la escuela
* Trabajos de años anteriores (https://mat.caminos.upm.es/wiki/Placa_Plana_(Grupo_26) )
* Google Gemini y Copilot M365 (Para facilitar la obtención de los código que introducíamos en matlab)
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]