MateWiki - Contribuciones del usuario [es]

Placa Plana (Grupo 20)

2025-12-04T10:16:39Z

Manuel Riesgo: /* Campo de Fuerzas */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones distribuidas en el volumen del material. Su cálculo se define mediante la divergencia del tensor de tensiones:

F = -∇ · σ
Al obtener valores numéricos del orden de 10⁻¹⁶ (un cero computacional), se confirma la ausencia de fuerzas de cuerpo físicas. Por tanto, la placa está en equilibrio estático, sometida únicamente a las acciones externas de contorno y sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:14:17Z

Manuel Riesgo: Se ha deshecho la revisión 98113 de Manuel Riesgo (disc.)

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas, calculadas como la divergencia del tensor de tensiones ($\mathbf{f} = -\nabla \cdot \boldsymbol{\sigma}$), representan las acciones distribuidas en el volumen del material. Dado que los resultados obtenidos son del orden de $10^{-16}$, lo cual constituye un cero computacional, se confirma la ausencia de fuerzas de cuerpo físicas. Por tanto, la placa se encuentra en estricto equilibrio estático, respondiendo únicamente a las cargas externas de contorno sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:13:42Z

Manuel Riesgo: Se ha deshecho la revisión 98124 de Manuel Riesgo (disc.)

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas, calculadas mediante la divergencia del tensor de tensiones ($\vec{F} = -\nabla \cdot \sigma$), representan las acciones distribuidas en la totalidad del volumen del material.En el análisis numérico, los valores resultantes del orden de $10^{-16}$ constituyen un cero computacional, lo que confirma la ausencia de fuerzas de cuerpo físicas reales. Por consiguiente, se verifica que la placa se encuentra en equilibrio estático, sometida únicamente a las acciones externas de contorno y sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:11:42Z

Manuel Riesgo: /* Campo de Fuerzas */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones distribuidas en la totalidad del volumen del material. Se calculan mediante la divergencia del tensor de tensiones:

F = -∇ · σ

En el análisis numérico, los valores resultantes del orden de 10⁻¹⁶ constituyen un cero computacional, lo que confirma la ausencia de fuerzas de cuerpo físicas reales. Por consiguiente, se verifica que la placa se encuentra en equilibrio estático, sometida únicamente a las acciones externas de contorno y sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:10:29Z

Manuel Riesgo: /* Campo de Fuerzas */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas, calculadas mediante la divergencia del tensor de tensiones ($\vec{F} = -\nabla \cdot \sigma$), representan las acciones distribuidas en la totalidad del volumen del material.En el análisis numérico, los valores resultantes del orden de $10^{-16}$ constituyen un cero computacional, lo que confirma la ausencia de fuerzas de cuerpo físicas reales. Por consiguiente, se verifica que la placa se encuentra en equilibrio estático, sometida únicamente a las acciones externas de contorno y sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:08:29Z

Manuel Riesgo: Se ha deshecho la revisión 98086 de Manuel Riesgo (disc.)

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas, calculadas como la divergencia del tensor de tensiones ($\mathbf{f} = -\nabla \cdot \boldsymbol{\sigma}$), representan las acciones distribuidas en el volumen del material. Dado que los resultados obtenidos son del orden de $10^{-16}$, lo cual constituye un cero computacional, se confirma la ausencia de fuerzas de cuerpo físicas. Por tanto, la placa se encuentra en estricto equilibrio estático, respondiendo únicamente a las cargas externas de contorno sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:05:45Z

Manuel Riesgo: /* Campo de Fuerzas */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas, calculadas como la divergencia del tensor de tensiones (\mathbf{f} = -\nabla \cdot \boldsymbol{\sigma}), representan las acciones distribuidas en el volumen del material. Dado que los resultados obtenidos son del orden de 10^{-16}, lo cual constituye un cero computacional, se confirma la ausencia de fuerzas de cuerpo físicas. Por tanto, la placa se encuentra en estricto equilibrio estático, respondiendo únicamente a las cargas externas de contorno sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T10:05:22Z

Manuel Riesgo: /* Campo de Fuerzas */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas, calculadas como la divergencia del tensor de tensiones ($\mathbf{f} = -\nabla \cdot \boldsymbol{\sigma}$), representan las acciones distribuidas en el volumen del material. Dado que los resultados obtenidos son del orden de $10^{-16}$, lo cual constituye un cero computacional, se confirma la ausencia de fuerzas de cuerpo físicas. Por tanto, la placa se encuentra en estricto equilibrio estático, respondiendo únicamente a las cargas externas de contorno sin presentar desequilibrios internos.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T09:38:23Z

Manuel Riesgo: /* Masa Total */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones externas que actúan sobre el interior del material. Se calculan mediante la divergencia del tensor de tensiones <math>F = -\nabla \cdot \sigma</math>. Al ser numéricamente nulo (matlab representa los puntos a pesar de tener magnitudes muy pequeñas de <math>10^{-16}</math>), la placa se encuentra en equilibrio estático bajo la acción exclusiva de la fuerza externa descrita en apartados anteriores, y no presenta fuerzas internas significativas.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total M de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad d(x,y)=(4-x)|y| sobre el dominio de la placa \mathcal{R}. Físicamente, como la densidad depende de (4-x), la masa se concentra más cerca del empotramiento (x=0) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T09:36:57Z

Manuel Riesgo: /* Masa Total */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones externas que actúan sobre el interior del material. Se calculan mediante la divergencia del tensor de tensiones <math>F = -\nabla \cdot \sigma</math>. Al ser numéricamente nulo (matlab representa los puntos a pesar de tener magnitudes muy pequeñas de <math>10^{-16}</math>), la placa se encuentra en equilibrio estático bajo la acción exclusiva de la fuerza externa descrita en apartados anteriores, y no presenta fuerzas internas significativas.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
La masa total $M$ de la placa representa la cantidad de materia acumulada en el sólido y se obtiene integrando la función de densidad $d(x,y)=(4-x)|y|$ sobre el dominio de la placa $\mathcal{R}$. Físicamente, como la densidad depende de $(4-x)$, la masa se concentra más cerca del empotramiento ($x=0$) y disminuye hacia el extremo libre.

La operación exacta a resolver es la siguiente integral doble:
:<math>M = \iint_{\mathcal{R}} d(x,y) \, dA = \int_{0}^{4} \int_{x/8}^{2-x/2} (4-x)y \, dy \, dx</math>

El resultado analítico exacto de esta integral es <math>M = \frac{48}{5} = \mathbf{9.6}</math> unidades de masa. A continuación, el código realiza la aproximación numérica de este valor.

[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)|y|');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T09:31:31Z

Manuel Riesgo: /* Masa Total */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones externas que actúan sobre el interior del material. Se calculan mediante la divergencia del tensor de tensiones <math>F = -\nabla \cdot \sigma</math>. Al ser numéricamente nulo (matlab representa los puntos a pesar de tener magnitudes muy pequeñas de <math>10^{-16}</math>), la placa se encuentra en equilibrio estático bajo la acción exclusiva de la fuerza externa descrita en apartados anteriores, y no presenta fuerzas internas significativas.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)|y|');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T09:31:11Z

Manuel Riesgo: Se ha deshecho la revisión 97949 de Manuel Riesgo (disc.)

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones externas que actúan sobre el interior del material. Se calculan mediante la divergencia del tensor de tensiones <math>F = -\nabla \cdot \sigma</math>. Al ser numéricamente nulo (matlab representa los puntos a pesar de tener magnitudes muy pequeñas de <math>10^{-16}</math>), la placa se encuentra en equilibrio estático bajo la acción exclusiva de la fuerza externa descrita en apartados anteriores, y no presenta fuerzas internas significativas.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)(y)');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-04T09:29:09Z

Manuel Riesgo: /* Masa Total */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones externas que actúan sobre el interior del material. Se calculan mediante la divergencia del tensor de tensiones <math>F = -\nabla \cdot \sigma</math>. Al ser numéricamente nulo (matlab representa los puntos a pesar de tener magnitudes muy pequeñas de <math>10^{-16}</math>), la placa se encuentra en equilibrio estático bajo la acción exclusiva de la fuerza externa descrita en apartados anteriores, y no presenta fuerzas internas significativas.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

%% Apartado 13: Calculo de la Masa Total y Visualizacion de Densidad
clc; clear; close all;

% 1. Definicion de la Region y Mallado Fino
h = 0.01; % Paso para la aproximacion numerica
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definicion de la Placa (Region R)
% g(x) = 2 - x/2 (GEOMETRIA CORREGIDA)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

% 3. Definicion de la Densidad d(x,y) = (4 - x) * |y|
Densidad = (4 - X) .* abs(Y);

% La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Calculo de la Masa (Integral Numerica)
dA = h * h; % Area de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('Masa Total Calculada (Aprox. Num.): M = %.4f\n', Masa_Total);
fprintf('(Valor exacto teorico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Visualizacion de la Densidad (Mapa 3D)
figure;
step_plot = 10; % Reducir resolucion para grafica 3D
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
xlabel('X'); ylabel('Y'); zlabel('Densidad d(x,y)');
title('Distribucion de Densidad d(x,y) = (4-x)|y|');

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-12-03T12:31:37Z

Manuel Riesgo: /* Masa Total */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
Una '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|600px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|800px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
El '''rotacional''' es un operador que indica la rotación local de cada punto de la placa. Este es igual a <math>|\nabla \times u|</math>. Realizando los cálculos, queda que es <math>|\nabla \times u| = 0.15x</math>. Esto indica que el '''rotacional''' crece '''linealmente'''a lo largo de la coordenada x, siendo '''máximo''' en el punto 4 y '''nulo''' en 0.
[[Archivo:Rotacionaldemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3);
axis tight;
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
El tensor deformaciones describe las deformaciones de la placa. Su diagonal mide las deformaciones a tracción o a compresión, mientras que las que están fuera de la diagonal miden las deformaciones de cizalladura.
[[Archivo:Manu_rot.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
Las tensiones tangenciales son fuerzas internas paralelas a las caras del material que provocan la cizalladura. A diferencia de las tensiones normales que estiran el material, estas tensiones provocan el deslizamiento entre capas adyacentes. En esta placa plana, la tensión tangencial es nula en el empotramiento (lado izquierdo) y máxima en el extremo derecho y ocurre solo en el plano <math>\sigma_{xy} = -\frac{x}{20} \quad (\text{para } \mu = 1)</math>
[[Archivo:Tensionesdemanuel.png|600px|thumb]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechas azules
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2);
axis equal;
grid on;

title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
La tensión de Von Mises es una magnitud escalar que indica el estado tensional de cada punto de un sólido. En nuestro caso, muestra las tensiones en el área de la placa plana. Su utilidad reside en su capacidad de determinar si la pieza que estudiamos va a romperse, y dónde lo va ha hacer. Para esto, comparamos el valor de la tensión de Von Mises con el del límite elástico del material.
La interpretación física de esta tensión se basa en la Teoría de la Energía de Distorsión, la cual afirma que los materiales dúctiles fallan cuando se distorsionan (cambian de forma). Para calcular la tensión, hemos usado la siguiente fórmula: <math>\sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}}</math>.

Las zonas con mayor tensión son las que se encuentran en el extremo superior derecho de la placa. Esto es debido a que las tensiones normales y tangenciales tienen sus valores más altos en esos puntos. La consecuencia es que la Energía de Distorsión Máxima en dicha esquina es muy elevada. Según el criterio de Von Mises, si la placa fallara, empezarçia a hacerlo desde ese extremo.
[[Archivo:Von_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
Las fuerzas volumétricas representan las acciones externas que actúan sobre el interior del material. Se calculan mediante la divergencia del tensor de tensiones <math>F = -\nabla \cdot \sigma</math>. Al ser numéricamente nulo (matlab representa los puntos a pesar de tener magnitudes muy pequeñas de <math>10^{-16}</math>), la placa se encuentra en equilibrio estático bajo la acción exclusiva de la fuerza externa descrita en apartados anteriores, y no presenta fuerzas internas significativas.
[[Archivo:Fuerzas_manuel.jpg|700px|thumb]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Masa Total==
[[Archivo:Manuel_densidad.jpg|400px|thumb]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./2);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 9.6000)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)|y|');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==
Las vigas en voladizo son un tipo de estructura que cuentan con un extremo, sujeto, anclado o empotrado en una pared y el otro libre. En dicho tipo de estructuras se encuentran:
* Cubiertas
* Techos salientes
* Puentes
* Marquesinas
Por lo general se usan en aquellas estructuras que requieren un espacio libre sin soportes intermedios.

[[Archivo:EstadioVicenteCalderon.jpg|miniaturadeimagen|Cubierta del estadio Vicente Calderón]]
[[Archivo:Marquesina.jpg|miniaturadeimagen|Cubierta de un aparcamiento]]

Placa Plana (Grupo 20)

2025-11-27T09:04:25Z

Manuel Riesgo: /* Introducción */

{{ TrabajoED | Placa Plana. Grupo 20 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC25/26|2025-26]] | Alejandro Trejo, Marcos Rodríguez-Barbero, Gloria García , Manuel Riesgo, Ángel De Miguel Pérez }}
[[Categoría:Teoría de Campos]]
[[Categoría:TC25/26]]
==Introducción==
ALEX ES UN PUTOOOOOO ALEX ES PUTO ALEXESPUTOALEXESPUTOELEXESPUTOALEXESPUTOALEXESPUTOALEXESPUTOELEXESPUTOALEXESPUTOALEXESPUTOALEXESPUTOELEXESPUTOALEXESPUTOALEXESPUTOALEXESPUTOELEXESPUTOALEXESPUTOUna '''placa plana''' es una superficie en '''dos dimensiones''', que en este caso representa la '''sección longitudinal''' de una '''viga rectangular''' que está en una '''situación de voladizo apoyada sobre la pared izquierda''', y ocupa la región <math>(x, y) \in [0, 4] \times [f(g), g(x)]</math>. Las '''funciones''' <math>f(x) g(x)</math> vienen definidas como <math>f(x) = \frac{x}{8}, \quad g(x) = 2 - \frac{x}{8}</math>.

Esta placa esta sometida a una '''temperatura''' que viene definida por la '''función''' <math>T(x, y) = (1 + (y - 1)^2)(4 - x)</math>.
 Además, los puntos de la placa sufren un '''desplazamiento''' causado por una '''fuerza de magnitud desconocida'''. Este desplazamiento es tal, que partiendo de un '''vector posición genérico''' para cualquier punto de la placa (<math>\vec{r}_0(x, y) = x\vec{i} + y\vec{j}</math>), al final del mismo el vector que nos sirve para determinar la posición de cualquier punto en la gráfica cambia a este:<math>\vec{r}_d(x, y) = \vec{r}_0(x, y) + \vec{u}(x, y)</math>.

Para realizar los diferentes cálculos, vamos a suponer que esta '''fuerza''' ha '''desplazado''' los puntos siguiendo el '''campo''': <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta</math>.

==Mallado de placa==
Para empezar, vamos a realizar un '''mallado''' de la '''sección longitudinal''' que represente los''' puntos interiores''' del '''sólido'''. Hemos utilizado un '''paso de muestreo''' h=1/10, y establecido los ejes en el '''rectángulo''' acotado por: <math>(x, y) \in [-1; 5] \times [-1; 3]</math>.
[[Archivo:Malladoplacaplana.png|thumb|700px|]]
{{matlab|codigo=
% 1. Configuración
h = 1/10;
color_malla = [0, 0.6, 0.6]; % Color Cían Oscuro

% 2. Generar Coordenadas Paramétricas (usamos estas en vez de x e y para que quede mejor ajustado a la figura)
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% 3. Transformación Matemática
% Calculamos los bordes superior e inferior para cada punto X
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos: calculamos la Y real basada en la altura V
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

X = U;
Y = y_abajo + factor_altura .* (y_arriba - y_abajo);

% 4. Visualización
figure('Color', 'w'); hold on;

% A) Dibujar las líneas VERTICALES
plot(X, Y, 'Color', color_malla, 'LineWidth', 0.5);

% B) Dibujar las líneas HORIZONTALES
plot(X', Y', 'Color', color_malla, 'LineWidth', 0.5);

% C) Dibujar el contorno
plot(u, u./8, 'k-', 'LineWidth', 2); % Borde Abajo
plot(u, 2 - u./8, 'k-', 'LineWidth', 2); % Borde Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde Izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde Derecho

% 5. Configuración final
axis([-1 5 -1 3]); % Zoom/Encuadre exacto
xlabel('x'); ylabel('y');
title('Mallado de la placa plana');
grid on;
box on;
hold off;
}}

==Curvas de nivel==
Las '''curvas de nivel''', en este caso las '''isotermas''', representan curvas en los cuales el '''valor''' (en este caso temperatura) es '''constante'''. Están representadas por colores según su '''temperatura'''. Las flechas negras representan la '''dirección de máximo crecimiento''' de la temperatura, es decir, el '''gradiente'''. (nota:(falta poner el punto con T max)) i
[[Archivo:Curvasdemanuel.png|marco]]
{{matlab|codigo=
% 1. Definición del Dominio y Mallado
h = 0.2; % Paso de muestreo
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Creamos la máscara (1 dentro, 0 fuera)
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la TEMPERATURA T(x,y)
% T(x,y) = (1 + (y-1)^2)(4-x)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);

% Calculamos la temperatura en toda la malla
T = T_func(X, Y);

% 4. Aplicar la Máscara
T(~dentro) = NaN;
X_plot = X; Y_plot = Y;
X_plot(~dentro) = NaN;
Y_plot(~dentro) = NaN;

% 5. Cálculo del Gradiente (Nabla T)
[dTdx, dTdy] = gradient(T, h, h);

% 6. Visualización
figure('Color', 'w', 'Position', [100 100 800 600]);
hold on;

% A) Pintar Curvas de Nivel (Isotermas)
% Usamos contour para ver las líneas de temperatura constante
[C, h_cont] = contour(X, Y, T, 20, 'LineWidth', 2);
clabel(C, h_cont, 'FontSize', 9, 'Color', 'k', 'FontWeight', 'bold');
colormap('jet');

% B) Pintar Campo Vectorial (Gradiente)
% quiver dibuja las flechas sobre la superficie
quiver(X, Y, dTdx, dTdy, 'k', 'LineWidth', 1.2);

% C) Dibujar el contorno de la placa
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Abajo
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Arriba
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Izquierda
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Derecha

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('x'); ylabel('y');
title({'Isotermas y Gradiente \nablaT', ...
'T(x,y) = (1 + (y-1)^2)(4-x)'});
colorbar;

% CÁLCULO DEL MÁXIMO
[max_temp, indice] = max(T(:));
[fil, col] = ind2sub(size(T), indice);
x_max = X(fil, col);
y_max = Y(fil, col);

fprintf('La temperatura máxima es %.2f en el punto (x=%.2f, y=%.2f)\n', ...
max_temp, x_max, y_max);
% Marcamos el punto máximo con una estrella roja
plot(x_max, y_max, 'p', 'MarkerFaceColor', 'r', 'MarkerEdgeColor', 'k', 'MarkerSize', 15);
hold off;
}}

==Ley de Fourier==
La Ley de Fourier enuncia que el '''calor''' fluye desde el punto más '''caliente''' hacia el más '''frío''', siguiendo el '''sentido opuesto''' del '''gradiente térmico''' y siendo '''proporcional''' a este, como hemos representado en la siguiente gráfica.
[[Archivo:Flujo de calor manuel.png|marco]]
{{matlab|codigo=
% 1. Configuración del Mallado
h = 0.2;
x = 0 : h : 4;
y = 0 : h : 2;
[X, Y] = meshgrid(x, y);

% 2. Definir la Geometría
y_abajo = X ./ 8;
y_arriba = 2 - (X ./ 8);

% Máscara lógica: determina qué puntos están dentro de la placa
dentro = (Y >= y_abajo) & (Y <= y_arriba);

% 3. Definir la Temperatura T(x,y)
T_func = @(x,y) (1 + (y - 1).^2) .* (4 - x);
T = T_func(X, Y);

% 4. Cálculos Físicos (Ley de Fourier)
% A) Calculamos el Gradiente (nabla T) mediante derivadas numéricas
[dTdx, dTdy] = gradient(T, h, h);

% B) Calculamos el Flujo de Calor Q
% Q = -k * nabla T. (Suponiendo k=1) -> Q apunta al frío
Qx = -dTdx;
Qy = -dTdy;

% 5. Limpieza de datos (Recortar la figura)
% Asignamos NaN (Not a Number) a todo lo que esté fuera de la placa.
% Esto hace que MATLAB no dibuje nada en esas zonas.
Qx(~dentro) = NaN;
Qy(~dentro) = NaN;
T(~dentro) = NaN;

% 6. Visualización
figure('Color', 'w', 'Name', 'Flujo de Calor Fourier');
hold on;

% A) FONDO: Mapa de Calor (contourf)
% 'LineStyle','none' quita las rayitas negras entre colores para que sea suave.
contourf(X, Y, T, 20, 'LineStyle', 'none');
colormap('jet'); % Paleta de colores: Azul (frío) -> Rojo (caliente)

% Barra de color explicativa
c = colorbar;
c.Label.String = 'Temperatura T(x,y)';
c.Label.FontSize = 10;

% B)El Campo Vectorial Q.
quiver(X, Y, Qx, Qy, 'k', 'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% C) Dibujo del contorno.
plot([0 4], [0 0.5], 'k-', 'LineWidth', 2); % Borde inferior
plot([0 4], [2 1.5], 'k-', 'LineWidth', 2); % Borde superior
plot([0 0], [0 2], 'k-', 'LineWidth', 2); % Borde izquierdo
plot([4 4], [0.5 1.5], 'k-', 'LineWidth', 2); % Borde derecho

% 7. Configuración Final
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;
xlabel('Eje x'); ylabel('Eje y');
title({'Vector Flujo de Calor', ...
'El calor fluye desde las capas más calientes hacia las más frías'});

hold off;
}}

==Punto y dirección de máxima variación térmica ==
El punto de '''máxima variación térmica''' es aquel en el que el '''gradiente térmico''' es '''máximo'''. Su '''dirección''' es la del '''gradiente''' en ese punto.

En ese punto y en '''sentido contrario''' al '''gradiente''' se encuentra el '''flujo de calor máximo'''.
[[Archivo:Apartado5manuel.png|marco]]
{{matlab|codigo=
% 1. Definición del Mallado y la Región
h = 0.05; % Paso del mallado (puedes ajustarlo a h=0.1 o h=0.01)
x = 0:h:4;
y = 0:h:2; % El rango de Y va de 0 a 2 según las funciones f(x) y g(x)
[X, Y] = meshgrid(x, y);

% Definición de los límites de la placa (Enunciado J)
% f(x) = x/8;
% g(x) = 2 - x/8;
Condition = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara (Ponemos NaN fuera de la placa)
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de las Derivadas Parciales (Gradiente)
% Usamos las fórmulas analíticas derivadas de T(x,y)
DerivadaX = -(1 + (Y - 1).^2);
DerivadaY = 2 .* (4 - X) .* (Y - 1);

% 3. Cálculo del Módulo del Gradiente
GradienteModulo = sqrt(DerivadaX.^2 + DerivadaY.^2);

% 4. Encontrar el Máximo Global
% Buscamos el valor máximo ignorando los NaNs
[MaxGradiente, IndiceLineal] = max(GradienteModulo);

% Convertimos el índice lineal a coordenadas de matriz (fila, columna)
[fila, col] = ind2sub(size(GradienteModulo), IndiceLineal);

% Obtenemos las coordenadas (x, y) y las componentes del vector en ese punto
PuntoMax = [X(fila, col), Y(fila, col)];
DirMax = [DerivadaX(fila, col), DerivadaY(fila, col)];

% Mostramos los resultados en la consola
fprintf('La variación máxima es: %.4f\n', MaxGradiente);
fprintf('Ocurre en el punto: (%.2f, %.2f)\n', PuntoMax(1), PuntoMax(2));
fprintf('Dirección del gradiente (vector): [%.2f, %.2f]\n', DirMax(1), DirMax(2));

% 5. Gráfica
figure;
hold on;
axis equal;
grid on;
title('Punto de Máxima Variación de Temperatura');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% Dibujar el contorno de la placa
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 1.5); % f(x)
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 1.5); % g(x)
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 1.5); % Pared izquierda
line([4 4], [0.5 1.5], 'Color', 'k', 'LineWidth', 1.5); % Borde derecho

% A) Dibujar el punto rojo
plot3(PuntoMax(1), PuntoMax(2), 10, 'ro', 'MarkerSize', 10, 'LineWidth', 3, 'MarkerFaceColor', 'r');

% B) Dibujar el vector de dirección en ese punto (Quiver)
% Normalizamos el vector para que se vea bien en la gráfica
escala = 0.5;
quiver(PuntoMax(1), PuntoMax(2), DirMax(1), DirMax(2), ...
escala, 'r', 'LineWidth', 2, 'MaxHeadSize', 0.5);

text(PuntoMax(1)+0.2, PuntoMax(2), sprintf('Max: %.2f', MaxGradiente));

hold off;
}}

==Campo de desplazamientos==
El '''campo de desplazamientos''' de un '''sólido''' es un '''campo vectorial''' que indica la '''dirección y sentido''' del '''desplazamiento''' de cada uno de los puntos que lo componen mediante '''vectores'''(las flechas rojas). Puede apreciarse que los que más se '''desplazan''' son aquellos que están más cerca del '''punto de aplicación de la fuerza''', mientras los que están más lejos apenas se desplazan.
[[Archivo:Desplazamiento_manuel.jpg|thumb|800px]]
{{matlab|codigo=

h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la región
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos la máscara )
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% 2. Cálculo del Campo de Desplazamientos (u_x, u_y)

% Primero necesitamos las coordenadas polares de cada punto (rho, theta)
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Definimos la componente escalar u_theta dada por el enunciado
% u(rho, theta) = -1/20 * rho^2 * cos(theta) * e_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Convertimos el vector de base polar a base cartesiana
% u_x = -u_theta * sin(theta)
% u_y = u_theta * cos(theta)
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% 3. Calcular la posición deformada

% Posición final = Posición inicial + Desplazamiento
X_final = X + Ux;
Y_final = Y + Uy;

% 4. Gráfica Comparativa

figure('Name', 'Deformación de la Placa', 'Color', 'w');

% PLACA ORIGINAL
subplot(1, 2, 1);
% Usamos mesh con Z=0 para dibujar la 'rejilla' plana
mesh(X, Y, zeros(size(X)), 'EdgeColor', 'b');
view(2); % Vista superior (2D)
axis equal; grid on;
title('Placa antes del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

% PLACA DEFORMADA
subplot(1, 2, 2);
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', 'b');
view(2);
axis equal; grid on;
title('Placa después del desplazamiento');
xlabel('Eje X'); ylabel('Eje Y');
axis([-0.5 4.5 -0.5 2.5]);

Apartado 5

figure('Name', 'Campo Vectorial de Desplazamientos');
hold on; axis equal; grid on;
title('Campo de Desplazamientos');

% Dibujamos contorno original de referencia
plot(X(:), Y(:), '.k', 'MarkerSize', 1);

% Dibujamos los vectores (quiver)
quiver(X, Y, Ux, Uy, 0, 'r', 'LineWidth', 1.5);

xlabel('Eje X'); ylabel('Eje Y');
xlim([-0.5 4.5]); ylim([-0.5 2.5]);
}}

==Desplazamiento del sólido==
Debido a la '''fuerza''' cuya magnitud desconocemos provoca un '''desplazamiento''' siguiendo el '''campo''' <math>\vec{u}(\rho, \theta) = -\frac{1}{20}\rho^2 \cos \theta \vec{e}_\theta.</math>, el '''sólido''' se '''desplazara''' siguiendo el mismo. Los '''puntos''' que más se han '''desplazado''' son los que están más cerca del '''punto de aplicación''' de la '''fuerza'''. Se adjuntan las gráficas en las que se aprecia el '''desplazamiento''' sufrido.(nota:no se ve el desplazamiento inferior, habría que ejecutar el código modificando los ejes para poder verlo)
[[Archivo:Apartado6deformacion.png|thumb|1000px]]
{{matlab|codigo=
% 1. Definición de Geometría y Desplazamientos
h = 0.1; % Paso del mallado
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la Región (
% La placa existe si Y >= X/8 Y Y <= 2 - X/8
Condicion = (Y >= X./8) & (Y <= 2 - X./8);

% Aplicamos máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo de Desplazamientos
% Coordenadas polares necesarias para la fórmula
Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);

% Valor escalar de u_theta
U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);

% Proyección a cartesianas
Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);

% --- Posición Final Deformada ---
X_final = X + Ux;
Y_final = Y + Uy;

% 2. Gráfica Comparativa de Sólidos Mallados
figure('Name', 'Comparación Antes/Después', 'Color', 'w', 'Position', [100, 100, 1000, 500]);

% SUBPLOT 1: Placa Original
subplot(1, 2, 1);
hold on;

mesh(X, Y, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2); % Fuerza la vista superior 2D
axis equal;
grid on;
box on;

title('Placa antes del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

% SUBPLOT 2: Placa Deformada
subplot(1, 2, 2);
hold on;
% Dibujamos la malla usando las coordenadas finales (X_final, Y_final)
mesh(X_final, Y_final, zeros(size(X)), 'EdgeColor', [0 0.7 0.9], 'FaceColor', 'none');

view(2);
axis equal;
grid on;
box on;

title('Placa después del desplazamiento', 'FontWeight', 'bold');
xlabel('Eje X');
ylabel('Eje Y');
axis([-1.5 4.5 0 2.5]);

sgtitle('Visualización del Sólido Mallado bajo Deformación'); % Título
}}

==Divergencia==
La '''divergencia''' es un '''operador''' que mide la variación de '''volumen'''. En nuestro caso, mide la variación del '''área''' de la '''placa plana'''.
 La leyenda del '''gráfico''' pone la zona de '''mayor expansión''' en '''colores cálidos''', mientras que la zona que se '''comprime''' está en colores fríos.
 Se puede apreciar como la parte superior se '''tracciona''' y aumenta su '''área''' debido a la '''fuerza''', mientras que la '''inferior''' se '''comprime'''.
[[Archivo:Divergencia_manuel.jpg|thumb|900px]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo Analítico de la Divergencia
Divergencia = Y ./ 20;

% 3. Encontrar Máximos, Mínimos y Nulos analíticamente en el mallado
max_val = max(Divergencia(:));
min_val = min(Divergencia(:));

% Encontramos los índices donde ocurren
[f_max, c_max] = find(Divergencia == max_val);
[f_min, c_min] = find(Divergencia == min_val);

% Puntos (x,y) correspondientes
PuntosMax = [X(f_max), Y(f_max)];
PuntosMin = [X(f_min), Y(f_min)];

% 4. Mostrar resultados en consola
fprintf('--- Resultados del Análisis de Divergencia ---\n');
fprintf('Divergencia Máxima: %.4f (Ocurre en y máximas)\n', max_val);
fprintf('Divergencia Mínima: %.4f (Ocurre en y = 0)\n', min_val);
fprintf('La divergencia es nula solo donde y = 0.\n');

% 5. Gráfica de la Divergencia
figure('Name', 'Divergencia del Desplazamiento', 'Color', 'w');
hold on;

% Dibujamos el mapa de colores
contourf(X, Y, Divergencia, 20, 'LineColor', 'none');
colormap(jet); % Mapa de colores clásico (Azul=Bajo, Rojo=Alto)
colorbar; % Barra lateral para saber qué valor es cada color

% Dibujar contorno de la placa para que quede bonito
x_borde = 0:0.1:4;
plot(x_borde, x_borde/8, 'k', 'LineWidth', 2);
plot(x_borde, 2 - x_borde/8, 'k', 'LineWidth', 2);
line([0 0], [0 2], 'Color', 'k', 'LineWidth', 2);

% Señalar Máximo y Mínimo
plot(PuntosMax(:,1), PuntosMax(:,2), 'rp', 'MarkerSize', 12, 'MarkerFaceColor', 'r'); % Estrella roja
plot(PuntosMin(:,1), PuntosMin(:,2), 'bo', 'MarkerSize', 8, 'MarkerFaceColor', 'b'); % Círculo azul

% Etiquetas y títulos
title('Cambio de Volumen Local');
xlabel('Eje X'); ylabel('Eje Y');
axis equal;
axis([-0.5 4.5 -0.5 2.5]);

% Leyenda manual para entender los puntos
legend('Divergencia (Color)', 'Bordes', '', '', 'Máxima Expansión', 'Mínima/Nula', ...
'Location', 'eastoutside');

hold off; }}

==Rotacional==
[[Archivo:Rotacionaldemanuel.png|marco]]
{{matlab|codigo=
% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 1. Definición del Mallado y Región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo del Rotacional (Magnitud)
% |Rot(u)| = 0.15 * x
Rotacional = 0.15 .* X;

% 3. Gráfica en 3D (Surface Plot)
figure('Name', 'Rotacional en 3D', 'Color', 'w');

% 'surf' crea la superficie 3D. X e Y son la base, Rotacional es la altura.
s = surf(X, Y, Rotacional);

% --- Estética de la gráfica 3D ---
shading interp; % Suaviza los colores (quita las líneas de la cuadrícula)
colormap(jet); % Mapa de colores (Azul -> Rojo)
alpha(0.9); % Un poco de transparencia (opcional)

view(3); % Pone la vista en perspectiva 3D automáticamente
axis tight; % Ajusta los ejes al contenido
grid on;
box on;

% Añadir barra de colores
c = colorbar;
c.Label.String = 'Magnitud |\nabla \times u|';
c.Label.FontSize = 11;

% Etiquetas y Título
title('Magnitud del Rotacional (Vista 3D)', 'FontSize', 12);
xlabel('Eje X (Posición)', 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontWeight', 'bold');
zlabel('Valor del Rotacional', 'FontWeight', 'bold');

% Añadir una luz para que se vea el volumen mejor
camlight left;
lighting phong;

% Opcional: Dibujar la proyección ("sombra") en el suelo para referencia
hold on;
contour(X, Y, Rotacional, 15, 'z', 'offset', 0, 'LineWidth', 1);
}}

==Tensor deformaciones==
[[Archivo:Manu_rot.jpg|miniaturadeimagen]]
{{matlab|codigo=
%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 1. Definición de Geometría y Material
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Placa J (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN; Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Cálculo de Componentes
% Deformaciones y Divergencia
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));
% Eps_zz es 0

% Tensiones Normales (Sigma = lambda*Div*I + 2*mu*Eps)
Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % y/20
Sig_zz = lambda .* Div_u; % y/20 (Por efecto Poisson)
Sig_xy = 2 .* mu .* (-X./40); % -x/20 (Cizalladura)

% 3. Gráfica 2D (Subplot)
figure('Name', 'Apartado 9: Tensiones Normales (2D)', 'Color', 'w', 'Position', [100, 100, 1200, 400]);

% Sigma XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{xx} (Eje i)'); xlabel('X'); ylabel('Y');

% Sigma YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{yy} (Eje j)'); xlabel('X'); ylabel('Y');

% Sigma ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('\sigma_{zz} (Eje k)'); xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones');
}}

==Tensiones tangenciales==
[[Archivo:Tensionesdemanuel.png|marco]]
{{matlab|codigo=
% 1. Definición del Mallado
h = 0.15; % Un paso un poco más grande para que las flechas no se amontonen
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Definición de la placa
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

% 2. Cálculo de la Tensión Tangencial (Sigma_xy)
% Recordamos del apdo 9: Sig_xy = 2*mu*eps_xy = 2*1*(-x/40) = -x/20
Sig_xy = -X ./ 20;

% 3. Definición del Vector Tangencial
% En la cara vertical (normal i), la tangencial es vertical (j).
% El vector es: (0, Sigma_xy)
U_vec = zeros(size(X)); % Componente X es 0
V_vec = Sig_xy; % Componente Y es el valor de la tensión

% 4. Gráfica
figure('Name', 'Apartado 10: Vector Tensión Tangencial', 'Color', 'w');

% Usamos quiver para dibujar las flechitas azules
% quiver(x, y, u, v)
quiver(X, Y, U_vec, V_vec, 'b', 'LineWidth', 1);

% Configuración de la vista
view(2); % Vista 2D superior
axis equal; % Ejes proporcionales
grid on; % Cuadrícula de fondo

% Títulos y Etiquetas
title('Tensiones tangenciales (Plano ortogonal a i)');
xlabel('Eje X');
ylabel('Eje Y');

% Ajuste de límites para ver bien la placa
axis([-0.5 4.5 -0.5 2.5]);
}}

==Tensión de Von Mises==
[[Archivo:Von_manuel.jpg|miniaturadeimagen]]
{{matlab|codigo=
%% Apartado 11: Tensión de Von Mises (Usando autovalores 'eig')
% Inicializamos la matriz de resultados con NaNs
VonMises_Calc = NaN(size(X));
PuntoMax_VM = [-1, -1];
Max_VM_Val = -1;

% Bucle para recorrer cada punto del mallado
[filas, cols] = size(X);
for f = 1:filas
for c = 1:cols
% Si el punto está dentro de la placa (no es NaN)
if ~isnan(X(f,c))
% 1. Construir el tensor de tensiones en ese punto (3x3)
s_xx = Sig_xx(f,c);
s_yy = Sig_yy(f,c);
s_zz = Sig_zz(f,c);
s_xy = Sig_xy(f,c);

Tensor = [s_xx, s_xy, 0;
s_xy, s_yy, 0;
0, 0, s_zz];

% 2. Calcular autovalores (Tensiones Principales)
sig_principales = eig(Tensor);
s1 = sig_principales(1);
s2 = sig_principales(2);
s3 = sig_principales(3);

% 3. Fórmula de Von Mises dada en el enunciado
vm = sqrt( ((s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2) / 2 );
VonMises_Calc(f,c) = vm;

% Guardar máximo para señalarlo después
if vm > Max_VM_Val
Max_VM_Val = vm;
PuntoMax_VM = [X(f,c), Y(f,c)];
end
end
end
end

% Gráfica
figure('Name', 'Apartado 11: Von Mises con Autovalores', 'Color', 'w');
contourf(X, Y, VonMises_Calc, 30, 'LineColor', 'none');
colormap(hot); % 'hot' suele usarse para mapas de "calor/tensión"
c = colorbar; c.Label.String = 'Tensión Von Mises (Pa)';

hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]);
title('Tensión de Von Mises (Cálculo mediante Autovalores)');
xlabel('Eje X'); ylabel('Eje Y');

% Señalar el punto máximo
plot(PuntoMax_VM(1), PuntoMax_VM(2), 'bp', 'MarkerSize', 14, 'MarkerFaceColor', 'b'); % Estrella azul
text(PuntoMax_VM(1)-1, PuntoMax_VM(2), sprintf('Máx: %.4f en (%.1f, %.1f)', Max_VM_Val, PuntoMax_VM), 'Color', 'b', 'FontWeight', 'bold');
hold off;}}

==Campo de Fuerzas==
[[Archivo:Fuerzas_manuel.jpg|miniaturadeimagen]]
{{matlab|codigo=
%% Apartado 12: Campo de Fuerzas Volumétricas (F = -div Sigma)
clc; clear; close all;

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

% Definición de la placa (Trapecio)
Condition = (Y >= X./8) & (Y <= 2 - X./8);
X(~Condition) = NaN;
Y(~Condition) = NaN;

lambda = 1; mu = 1;

% 2. Recalculamos las Tensiones (Necesarias para derivar)
% Usamos las fórmulas analíticas que ya conocemos
Div_u = Y ./ 20;
Eps_xx = Y ./ 20;
Eps_yy = zeros(size(X));

Sig_xx = lambda .* Div_u + 2 .* mu .* Eps_xx; % = 3y/20
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; % = y/20
Sig_xy = -X ./ 20; % = -x/20 (cizalladura)

% 3. Cálculo de la Divergencia del Tensor (Numéricamente)
% F = -div(sigma)
% Fx = -( d(Sxx)/dx + d(Sxy)/dy )
% Fy = -( d(Sxy)/dx + d(Syy)/dy )

% La función gradient calcula derivadas centrales.
% Sintaxis: gradient(Matriz, paso_x, paso_y)
[dSxx_dx, dSxx_dy] = gradient(Sig_xx, h, h);
[dSxy_dx, dSxy_dy] = gradient(Sig_xy, h, h);
[dSyy_dx, dSyy_dy] = gradient(Sig_yy, h, h);

Fx = - (dSxx_dx + dSxy_dy);
Fy = - (dSxy_dx + dSyy_dy);

% 4. Comprobación de Magnitud (Para ver si es cero)
MagnitudF = sqrt(Fx.^2 + Fy.^2);
max_F = max(MagnitudF(:));

fprintf('--- Resultado Apartado 12 ---\n');
fprintf('La fuerza máxima calculada es: %e\n', max_F);

if max_F < 1e-10
fprintf('CONCLUSIÓN: La fuerza es prácticamente NULA (Equilibrio).\n');
subtitle_text = 'Fuerza \approx 0 (Equilibrio Estático)';
else
subtitle_text = 'Existen fuerzas volumétricas';
end

% 5. Gráfica
figure('Name', 'Apartado 12: Campo de Fuerzas', 'Color', 'w');
hold on;

% Dibujamos los vectores.
% Como son casi cero, MATLAB pintará puntos. Para ver "algo",
% a veces se normalizan, pero lo correcto es mostrar que no hay fuerza.
quiver(X, Y, Fx, Fy, 'r');

% Dibujar bordes
plot([0 4 4 0 0], [0 0.5 1.5 2 0], 'k--', 'LineWidth', 0.5); % Caja aproximada

title('Campo de Fuerzas Volumétricas');
subtitle(subtitle_text);
xlabel('Eje X'); ylabel('Eje Y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);
grid on;

% Añadimos una nota en la gráfica explicándolo
text(1, 1, {'Fuerza Nula', '(puntos indican magnitud ~0)'}, ...
'Color', 'r', 'FontWeight', 'bold', 'HorizontalAlignment', 'center');

hold off;}}

==Densidad==
[[Archivo:Manuel_densidad.jpg|miniaturadeimagen]]
{{matlab|codigo=
%% Apartado 13: Cálculo de la Masa Total
clc; clear; close all;

% 1. Definición del Mallado
% Usamos un paso fino (h=0.01) para que la integral sea precisa
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Definición de la Placa (Región)
Condition = (Y >= X./8) & (Y <= 2 - X./8);

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

% Importante: La densidad fuera de la placa es 0
Densidad(~Condition) = 0;

% 4. Cálculo de la Masa (Integral Numérica)
% Masa = Suma(Densidad * Area_diferencial)
dA = h * h; % Área de cada celda de la malla
Masa_Total = sum(Densidad(:)) * dA;

% 5. Mostrar Resultado
fprintf('------------------------------------------------\n');
fprintf('RESULTADO APARTADO 13\n');
fprintf('------------------------------------------------\n');
fprintf('Masa Total Calculada: %.4f unidades de masa\n', Masa_Total);
fprintf('(Valor exacto teórico: 13.3333)\n');
fprintf('------------------------------------------------\n');

% 6. Gráfica de la Densidad (Opcional, para visualizar)
figure('Name', 'Apartado 13: Distribución de Masa', 'Color', 'w');
% Bajamos resolución solo para pintar rápido
step_plot = 10;
surf(X(1:step_plot:end, 1:step_plot:end), ...
Y(1:step_plot:end, 1:step_plot:end), ...
Densidad(1:step_plot:end, 1:step_plot:end));

shading interp; colormap(parula); colorbar;
view(3); grid on; axis tight;
title('Distribución de Densidad d(x,y) = (4-x)|y|');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
}}

==Ejemplos de uso==