Placa Plana (Grupo 09)

Trabajo realizado por estudiantes
Título	Placa plana. Grupo 09
Asignatura	Teoría de Campos
Curso	2025-26
Autores	Rafael Gonzalez Gomez Mario Belinchón Buendía Alejandro Morales Tari Pablo Márquez Blanco
Este artículo ha sido escrito por estudiantes como parte de su evaluación en la asignatura

1 Introducción

Consideramos la sección longitudinal de una viga en voladizo de geometría rectangular (en dimensión 2). Esta viga ocupa la región mostrada en la Figura 1, y permanece anclada en la pared vertical situada en el lado izquierdo. La zona que vamos a estudiar se describe mediante:

[math] (x,y) \in [0,4] \times [f(x),, g(x)], \qquad f(x)=\frac{x}{8}, \qquad g(x)= 2-\frac{x}{8} [/math]

En esta placa se consideran dos magnitudes físicas relevantes. La primera es el campo de temperaturas, modelado por la función:

[math] T(x,y)=\big(1+(y-1)^2\big),(4-x) [/math]

La segunda magnitud corresponde al campo de desplazamientos [math]\vec u(x,y)[/math], producido por una fuerza externa —cuyo valor exacto no conocemos— y que deforma la placa.

Para describir la deformación, sea [math]\vec r_0(x,y)=x,\vec i + y,\vec j[/math] el vector de posición inicial de cada punto. Entonces, tras aplicarse la fuerza, la nueva posición de un punto queda dada por:

[math] \vec r_d(x,y)=\vec r_0(x,y)+\vec u(x,y) [/math]

Supondremos que la fuerza aplicada induce un desplazamiento expresado, en coordenadas polares [math](\rho,\theta)[/math], mediante:

[math] \vec u(\rho,\theta)= -\frac{1}{20},\rho^2\cos\theta ; \vec e_\theta [/math]

Este modelo permite estudiar tanto la distribución térmica en la viga como la deformación resultante, proporcionando una base adecuada para analizar su comportamiento estructural.

2 Mallado

Para comenzar, construiremos un mallado de la sección longitudinal que nos permita representar los puntos interiores del sólido. Para ello, hemos empleado un paso de muestreo de [math]h = \tfrac{1}{10}[/math] y hemos definido la malla sobre el rectángulo que delimita los ejes coordenados:

[math] (x, y) \in [-1,, 5] \times [-1,, 3] [/math]

Este mallado servirá como base para discretizar la región de interés y facilitar los cálculos posteriores.

h = 1/10;
color_malla = [0, 1, 0]; % Color 

% Coordenadas
u = 0 : h : 4;
v = 0 : h : 2;
[U, V] = meshgrid(u, v);

% Calculamos los bordes 
y_abajo = U ./ 8;
y_arriba = 2 - (U ./ 8);

% Interpolamos
factor_altura = V ./ 2; % Va de 0 (abajo) a 1 (arriba)

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

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

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

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

% 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

% 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;

3 Curvas de nivel

A continuación se representan las curvas de nivel de la temperatura con el fin de identificar visualmente la zona donde esta alcanza su valor máximo. A partir de la gráfica puede apreciarse que los puntos donde la temperatura es mayor son:

[math](x,y) = (0,0) \quad \text{y} \quad (0,2)[/math]

Además, calculamos el gradiente de la temperatura para analizar la dirección de mayor variación de esta magnitud. El gradiente viene dado por:

[math] \nabla T(x,y) = \left( \frac{\partial T}{\partial x},, \frac{\partial T}{\partial y} \right) = \Big( -\big(1+(y-1)^2\big),; (4-x)\cdot 2(y-1) \Big). [/math]

En la representación gráfica se observa que el vector gradiente es ortogonal a las curvas de nivel, tal como establece la teoría: apunta siempre en la dirección de crecimiento más rápido de la temperatura.

Figura 2

clc; clear; close all;

% Parámetros del mallado
h = 0.1;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);  

% Funciones de los bordes de la placa
f = @(x) x/8;
g = @(x) 2 - x/8;

% Zona válida de la placa
zona = (Y >= f(X)) & (Y <= g(X));

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

% Enmascarado visual
T_mask = T;
T_mask(~zona) = NaN;

% Cálculo del gradiente de T
Ux = -(1 + (Y - 1).^2);          
Vy =  2 .* (Y - 1) .* (4 - X);    

Ux(~zona) = NaN;
Vy(~zona) = NaN;

% Gráfica
figure(1); clf; hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;

title("Distribución de la Temperatura y el Gradiente \nabla T");
xlabel("x");
ylabel("y");

% Mapa de calor de T
contourf(X, Y, T_mask, 20, 'LineStyle', 'none');   
colormap("parula");  
colorbar;  
ylabel(colorbar, 'Temperatura T(x,y)');

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

% Campo vectorial (gradiente)
paso = 3;
quiver(X(1:paso:end, 1:paso:end), Y(1:paso:end, 1:paso:end), Ux(1:paso:end, 1:paso:end), Vy(1:paso:end, 1:paso:end), 1.2, 'c', 'LineWidth', 1);  

% Dibujar contorno de la placa (en color verde oscuro)
plot(x, f(x), 'g-', 'LineWidth', 2);  
plot(x, g(x), 'g-', 'LineWidth', 2);   
plot([0 0], [f(0) g(0)], 'g-', 'LineWidth', 2);   
plot([4 4], [f(4) g(4)], 'g-', 'LineWidth', 2);  

% Señalar los puntos de máximos (marcadores en forma de círculo)
plot(0, 0, 'ko', 'MarkerFaceColor', 'y', 'MarkerSize', 12);  
plot(0, 2, 'ko', 'MarkerFaceColor', 'y', 'MarkerSize', 12);  

% Etiquetas de los puntos de máximos
text(0.1, 0, 'Máx T', 'Color', 'black', 'FontWeight', 'bold');
text(0.1, 2, 'Máx T', 'Color', 'black', 'FontWeight', 'bold');

hold off;

saveas(gcf,'curvasdenivelgrupo009.png');

4 Ley de Fourier

Según la ley de Fourier, el flujo de energía calorífica [math]\vec{Q}[/math] viene dado por:

[math]\vec{Q} = -\kappa , \nabla T[/math]

donde [math]\kappa[/math] representa la conductividad térmica del material. En nuestro caso, consideramos [math]\kappa = 1[/math], de modo que la expresión se simplifica a:

[math]\vec{Q} = - \nabla T[/math]

Bajo esta suposición, en la representación gráfica puede apreciarse que el flujo calorífico es simplemente el opuesto del gradiente de la temperatura, señalando siempre la dirección de máxima disminución térmica.

% Mallado y dominio geométrico
paso = 0.2;
xx = 0:paso:4;
yy = 0:paso:2;
[X, Y] = meshgrid(xx, yy);

% Bordes superior e inferior de la región física
lim_inf = X / 8;
lim_sup = 2 - X / 8;

% Máscara lógica: puntos válidos
zona = (Y >= lim_inf) & (Y <= lim_sup);

% Campo escalar de temperatura
Temp = (1 + (Y - 1).^2) .* (4 - X);   % misma función, escrita directamente
Temp(~zona) = NaN;                   % filtrado de la zona útil

% Gradiente numérico y flujo térmico
% gradient devuelve: [dT/dy , dT/dx]
[dTy, dTx] = gradient(Temp, paso);

flujo_x = -dTx;    % Ley de Fourier en 2D
flujo_y = -dTy;

flujo_x(~zona) = NaN;
flujo_y(~zona) = NaN;

% Representación gráfica
fig = figure('Color','white','Name','Mapa de flujo térmico');
hold on;

% Campo escalar coloreado
contourf(X, Y, Temp, 20, 'LineStyle','none');
colormap jet;

% Indicador de escala
barra = colorbar;
barra.Label.String = 'T(x,y)';
barra.Label.FontSize = 10;

% Representación vectorial del flujo
quiver(X, Y, flujo_x, flujo_y, 'k', ...
       'LineWidth', 1.2, 'AutoScaleFactor', 1.5);

% Dibujar la frontera física del sólido
tramo = [0 4];
plot(tramo, [0 0.5], 'k', 'LineWidth', 2);
plot(tramo, [2 1.5], 'k', 'LineWidth', 2);
plot([0 0], [0 2],   'k', 'LineWidth', 2);
plot([4 4], [0.5 1.5],'k', 'LineWidth', 2);

% Ajustes finales del gráfico
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;

xlabel('x');
ylabel('y');
title({'Campo de Flujo Térmico'});

hold off;

5 Gradiente Térmico

El punto de máxima variación térmica corresponde al lugar donde el gradiente de la temperatura alcanza su valor máximo. En la práctica, esto se obtiene igualando la derivada del gradiente a cero.

Mientras que la variación térmica sigue la dirección del gradiente, el flujo de calor más intenso se orienta en sentido contrario, es decir, hacia donde disminuye la temperatura.

Paso 1: Definición de la función para maximizar

Llamamos a la función:

[math]G(x,y) = |\nabla T|^2[/math]

Desarrollando los términos:

[math]G(x,y) = \big(1+(y-1)^2\big)^2 + \big(2(y-1)(4-x)\big)^2[/math]

[math]G(x,y) = (y^2 - 2y + 2)^2 + 4(y-1)^2(4-x)^2[/math]

Paso 2: Cálculo de los puntos críticos

Para maximizar la función, derivamos y resolvemos el sistema:

[math]\frac{\partial G}{\partial x} = -8 (y-1)^2 (4-x) = 0[/math] [math]\frac{\partial G}{\partial y} = 4 (y-1) \big(1 + (y-1)^2 + 2 (4-x)^2 \big) = 0[/math]

Al resolver este sistema, encontramos que los mínimos se sitúan sobre la recta:

[math]y = 1[/math]

Como no hay máximos aislados dentro del dominio, los máximos deben encontrarse en la frontera:

Borde izquierdo: [math]x=0[/math]

Borde derecho: [math]x=4[/math]

Curva inferior: [math]y = x/8[/math]

Curva superior: [math]y = 2 - x/8[/math]

Tras analizar los límites del recinto, los máximos de la función del gradiente térmico se localizan en el borde izquierdo, [math]x=0[/math]. Las coordenadas de los máximos son:

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

Paso 3: Cálculo de la máxima variación térmica

El valor de la norma del gradiente es igual para P(1) y P(2). Calculamos, por ejemplo, para P(1) = (0,0):

[math]\nabla T(0,0) = \big(-(1 + (0-1)^2), 2(0-1)(4-0)\big) = (-2,-8)[/math]

[math]|\nabla T(0,0)| = \sqrt{(-2)^2 + (-8)^2} = \sqrt{4 + 64} = 2\sqrt{17} \approx 8.246[/math]

Por lo tanto, la máxima variación térmica en la placa se produce en los puntos P(1) y P(2) y tiene un valor aproximado de 8.246.

Figura 4:Máxima Variación de T

clc;
clear;
close all;

% Mallado de la región
h = 0.05;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% Curvas que delimitan la placa
y_inf = X./8;
y_sup = 2 - X./8;

% Puntos que pertenecen a la placa
enPlaca = (Y >= y_inf) & (Y <= y_sup);

% Gradiente de T(x,y)
% T(x,y) = (1 + (y - 1)^2) * (4 - x)
Tx = -(1 + (Y - 1).^2);          % dT/dx
Ty =  2 .* (Y - 1) .* (4 - X);   % dT/dy

% Módulo del gradiente
NormaGrad = sqrt(Tx.^2 + Ty.^2);

% Fuera de la placa lo ponemos a NaN para que no se pinte
NormaGrad(~enPlaca) = NaN;

% Búsqueda de los puntos de máximo
max_val = max(NormaGrad(:));             % valor máximo del módulo
[filas, columnas] = find(NormaGrad == max_val);

% Coordenadas de los puntos donde se alcanza el máximo
x_max = X(filas, columnas);
y_max = Y(filas, columnas);

% Componentes del vector gradiente en esos puntos
u_dir = Tx(filas, columnas);
v_dir = Ty(filas, columnas);

% Representación gráfica
figure('Name', 'Máxima variación de T');
hold on;
axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;

title('Puntos de máxima variación de T');
xlabel('x');
ylabel('y');

% Mapa de colores con el módulo del gradiente
contourf(X, Y, NormaGrad, 20, 'LineStyle', 'none');
colormap(jet);
colorbar;

% Contorno aproximado de la placa
xp = [0 4 4 0 0];
yp = [0 0.5 1.5 2 0];
plot(xp, yp, 'k', 'LineWidth', 1.5);

% Puntos de máximo
plot(x_max, y_max, 'ro', 'MarkerSize', 7, 'MarkerFaceColor', 'r');

% Vectores dirección del gradiente en los máximos
quiver(x_max, y_max, u_dir, v_dir, 0.5, 'k', 'LineWidth', 2, 'MaxHeadSize', 0.5);

hold off;

% Información por pantalla
fprintf('La variación máxima del módulo del gradiente es: %.2f\n', max_val);
fprintf('Se alcanza en los siguientes puntos:\n');

for k = 1:length(x_max)
    fprintf('Punto %d: x = %.2f, y = %.2f, vector gradiente = [%.2f, %.2f]\n', ...
        k, x_max(k), y_max(k), u_dir(k), v_dir(k));
end

6 Campo de Desplazamientos

El campo de desplazamientos de un sólido se representa mediante un campo vectorial, que indica la dirección y sentido del desplazamiento de cada punto mediante vectores (representados como flechas rojas).

Como se puede observar, los puntos que se encuentran más próximos al punto de aplicación de la fuerza experimentan los desplazamientos más grandes, mientras que los situados más alejados apenas se mueven.

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 Máscara
X(~Condicion) = NaN;
Y(~Condicion) = NaN;

% Cálculo del Campo de Desplazamientos 

Rho = sqrt(X.^2 + Y.^2);
Theta = atan2(Y, X);


U_theta_val = -1/20 .* Rho.^2 .* cos(Theta);


Ux = -U_theta_val .* sin(Theta);
Uy = U_theta_val .* cos(Theta);


% Calcular la posición deformada

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


% 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(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]);

7 Desplazamiento del Sólido

Debido a la fuerza de magnitud desconocida, el sólido experimenta un desplazamiento descrito por el campo vectorial:

[math]\vec{u}(\rho, \theta) = -\frac{1}{20},\rho^2 \cos \theta ; \vec{e}_\theta[/math]

El sólido se deforma siguiendo este campo de desplazamientos. Como era de esperar, los puntos más próximos al punto de aplicación de la fuerza son los que sufren los mayores desplazamientos, mientras que los situados más lejos apenas se mueven.

Se adjuntan las gráficas que muestran el desplazamiento sufrido. (Nota: el desplazamiento inferior no se aprecia en la visualización actual; sería necesario ajustar los ejes en el código para visualizarlo correctamente).

% 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 

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

% Cálculo de Desplazamientos

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;

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

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

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

view(2); 
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]);

% 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

8 Divergencia

La divergencia [math]\nabla \cdot \vec{u}[/math] mide la variación de volumen local en el sólido. En nuestro caso, el cálculo da como resultado:

[math]\nabla \cdot \vec{u} = \frac{y}{20}[/math]

Este resultado indica que la placa experimenta una expansión positiva, que aumenta linealmente con la altura, debido al estiramiento de las fibras superiores.

En la representación gráfica se observa la distribución de la divergencia mediante franjas de color:

En azul se encuentra la base, donde el volumen permanece prácticamente constante.

Hacia la parte superior, el color se degrada progresivamente hasta un rojo intenso, indicando el punto de máxima expansión, independiente de la posición horizontal 𝑥 x.

Figura 7

clc; clear; close all;

% Definir Malla y Placa
h = 0.05;
[X, Y] = meshgrid(0:h:4, 0:h:2); 
f = @(x) x/8;
g = @(x) 2 - x/8; 
EnPlaca = (Y >= f(X)) & (Y <= g(X)); 

% Divergencia
Div = Y/20;  
Div(~EnPlaca) = NaN;  

% Visualización
figure; clf; hold on;
axis equal; axis([-0.5 4.5 -0.5 2.5]); box on;
title('Divergencia: Cambio de Volumen');
xlabel('X'); ylabel('Y');

% Mapa de calor de la Divergencia
contourf(X, Y, Div, 20, 'LineStyle', 'none');  
colormap(parula);  
colorbar;  
ylabel(colorbar, 'Valor de Divergencia');

% Dibujar bordes de la placa
x_b = linspace(0, 4, 200);
plot(x_b, x_b/8, 'k-', 'LineWidth', 1);   
plot(x_b, 2 - x_b/8, 'k-', 'LineWidth', 1);   
plot([0 0], [0 2], 'k-', 'LineWidth', 1);   
plot([4 4], [0 2], 'k-', 'LineWidth', 1);   

% Señalar puntos clave (cambié las estrellas por círculos)
plot(0, 2, 'go', 'MarkerSize', 12, 'MarkerFaceColor', 'g');
text(0.1, 2.05, 'Max Expansión', 'FontWeight', 'bold', 'Color', 'g');

plot(0, 0, 'ro', 'MarkerSize', 12, 'MarkerFaceColor', 'r');  
text(0.1, -0.05, 'Divergencia Nula', 'FontWeight', 'bold', 'Color', 'r');

hold off;
saveas(gcf,'divergencia09.png');

9 Rotacional

Se calcula el rotacional [math]|\nabla \times \vec{u}|[/math] en todos los puntos del sólido.

Los resultados muestran que los puntos más alejados del origen y alineados con el eje 𝑥 x experimentan los mayores valores de rotacional, indicando que estas zonas sufren la mayor rotación local debido al campo de desplazamientos aplicado.

%Divergencia
clc; clear; close all;

% Definir Malla 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;

% Cálculo del Rotacional
Rotacional = 0.15 .* X; 

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

s = surf(X, Y, Rotacional);

% Estética de la gráfica 3D
shading interp;  
colormap(spring); 
alpha(0.9);  

% Ajuste de la vista para la inclinación
view(45, 30);  
axis tight;
grid on;
box on;

% nombres a los ejes y título
title('Magnitud del Rotacional a lo largo del eje X');
xlabel('Eje X (Posición)', 'FontSize', 12, 'FontWeight', 'bold');
ylabel('Eje Y (Posición)', 'FontSize', 12, 'FontWeight', 'bold');
zlabel('Magnitud del Rotacional', 'FontSize', 12, 'FontWeight', 'bold');

% barra de colores
c = colorbar;
c.Label.String = 'Magnitud';
c.FontSize = 12;

% Puntos Clave 
hold on;
plot3(0, 2, 0.6, 'go', 'MarkerSize', 12, 'MarkerFaceColor', 'g');  % Max Expansión
text(0.1, 2.05, 'Max Expansión', 'FontWeight', 'bold', 'Color', 'g');

plot3(0, 0, 0.1, 'bo', 'MarkerSize', 12, 'MarkerFaceColor', 'b');  % Divergencia Nula
text(0.1, -0.05, 'Divergencia Nula', 'FontWeight', 'bold', 'Color', 'b');
hold off;

10 Tensores Deformacionales

Se define el tensor de deformaciones como la parte simétrica del gradiente del campo de desplazamientos [math]\vec{u}[/math]:

[math]\varepsilon(\vec{u}) = \frac{1}{2} \big( \nabla \vec{u} + (\nabla \vec{u})^T \big)[/math]

En un medio elástico lineal, isótropo y homogéneo, los desplazamientos permiten expresar el tensor de tensiones [math]\sigma[/math] mediante la relación de Hooke generalizada:

[math]\sigma = \lambda , (\nabla \cdot \vec{u}) , I + 2 \mu , \varepsilon(\vec{u})[/math]

donde:

[math]I[/math] es el tensor identidad en [math]\mathbb{R}^3[/math],

[math]\lambda[/math] y [math]\mu[/math] son los coeficientes de Lamé, que dependen de las propiedades elásticas del material.

Tomando [math]\lambda = \mu = 1[/math], se representan las tensiones normales en las direcciones de los ejes coordenados:

[math]\vec{i} \cdot \sigma \cdot \vec{i}[/math] — tensión normal en la dirección del eje 𝑥 x,

[math]\vec{j} \cdot \sigma \cdot \vec{j}[/math] — tensión normal en la dirección del eje 𝑦 y,

[math]\vec{k} \cdot \sigma \cdot \vec{k}[/math] — tensión normal en la dirección del eje 𝑧 z.

Solo se representan las componentes no nulas, mostrando cómo se distribuyen las tensiones normales en el sólido bajo el campo de desplazamientos aplicado.

Figura 9

%% Apartado 9 (Versión 2D): Tensiones Normales
clc; clear; close all;

% 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;

% 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; 
Sig_yy = lambda .* Div_u + 2 .* mu .* Eps_yy; 
Sig_zz = lambda .* Div_u; 
Sig_xy = 2 .* mu .* (-X./40);

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

% XX
subplot(1, 3, 1);
contourf(X, Y, Sig_xx, 20, 'LineColor', 'none');
colormap(spring);  % Cambiar la paleta de colores
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('Tensión Normal en X', 'Interpreter', 'latex');
xlabel('X'); ylabel('Y');

% YY
subplot(1, 3, 2);
contourf(X, Y, Sig_yy, 20, 'LineColor', 'none');
colormap(spring);  % Cambiar la paleta de colores
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('Tensión Normal en Y', 'Interpreter', 'latex');
xlabel('X'); ylabel('Y');

% ZZ
subplot(1, 3, 3);
contourf(X, Y, Sig_zz, 20, 'LineColor', 'none');
colormap(spring);  % Cambiar la paleta de colores
axis equal; axis([-0.5 4.5 -0.5 2.5]); colorbar;
title('Tensión Normal en Z', 'Interpreter', 'latex');
xlabel('X'); ylabel('Y');

sgtitle('Componentes Normales del Tensor de Tensiones', 'Interpreter', 'latex');

11 Tensiones tangenciales

Se representan las tensiones tangenciales respecto al plano ortogonal al eje [math]\vec{i}[/math], definidas como:

[math]|\sigma \cdot \vec{i} - (\vec{i} \cdot \sigma \cdot \vec{i}) , \vec{i}|[/math]

En la gráfica se muestran únicamente las componentes no nulas, permitiendo visualizar las tensiones tangenciales que actúan sobre los planos perpendiculares al eje 𝑥 x.

% Representación del vector de tensión tangencial
clc; clear; close all;

% 1) Crear la malla
paso = 0.15;
[X, Y] = meshgrid(0:paso:4, 0:paso:2);

% 2) Zona válida (la placa con forma trapezoidal)
bajo  = X/8;
alto  = 2 - X/8;

enZona = (Y >= bajo) & (Y <= alto);

% Quitar puntos fuera
X(~enZona) = NaN;
Y(~enZona) = NaN;

% 3) Tensión tangencial τ_xy
tau_xy = -X/20;

% 4) Componentes del vector
u_comp = zeros(size(X));   % componente horizontal
v_comp = tau_xy;           % componente vertical

% 5) Dibujar el campo vectorial
figure('Name','Tensión tangencial','Color','w');

quiver(X, Y, u_comp, v_comp, 'r', 'LineWidth', 1);

title('Campo de Tensión Tangencial \tau_{xy}');
xlabel('x');
ylabel('y');

axis equal;
axis([-0.5 4.5 -0.5 2.5]);
grid on;

12 Tensión de Von Mises

La tensión de Von Mises se define mediante la expresión:

[math] \sigma_{VM} = \sqrt{\frac{(\sigma_1 - \sigma_2)^2 + (\sigma_2 - \sigma_3)^2 + (\sigma_3 - \sigma_1)^2}{2}} [/math]

Esta fórmula combina las diferencias entre las tensiones principales (𝜎1,𝜎2,𝜎3σ1,σ2,σ3) y permite calcular el esfuerzo equivalente que experimenta el material, útil para evaluar la resistencia frente a la plasticidad o el fallo.

Figura 11

% Cálculo de tensiones y Von Mises en una placa
clc; clear; close all;

% 1) Crear la malla
paso = 0.1;
[X, Y] = meshgrid(0:paso:4, 0:paso:2);

% Límites del trapecio
limInf = X/8;
limSup = 2 - X/8;
zona = (Y >= limInf) & (Y <= limSup);

% 2) Definir desplazamientos u_x y u_y
ux = (X.*Y)/20;
uy = -(X.^2)/20;

% Derivadas conocidas
ux_x = Y/20;
ux_y = X/20;
uy_x = -X/10;
uy_y = zeros(size(X));

divU = ux_x + uy_y;

% 3) Tensiones (lambda = mu = 1)
lambda = 1;
mu = 1;

% Deformaciones
exx = ux_x;
eyy = uy_y;
exy = 0.5 * (ux_y + uy_x);
ezz = zeros(size(X));

% Tensiones
sxx = lambda*divU + 2*mu*exx;
syy = lambda*divU + 2*mu*eyy;
szz = lambda*divU + 2*mu*ezz;
sxy = 2*mu*exy;

% 4) Cálculo de Von Mises usando autovalores
VM = NaN(size(X));

% Guardar índices dentro de la zona
[I,J] = find(zona);
N = length(I);

for k = 1:N
    r = I(k);
    c = J(k);

    % Matriz sigma
    S = [sxx(r,c) sxy(r,c) 0;
         sxy(r,c) syy(r,c) 0;
         0        0        szz(r,c)];

    % Autovalores
    vals = eig(S);
    
    s1 = vals(1);
    s2 = vals(2);
    s3 = vals(3);

    % Von Mises
    VM(r,c) = sqrt( ( (s1-s2)^2 + (s2-s3)^2 + (s3-s1)^2 ) / 2 );
end

% 5) Encontrar máximo
[maxVM, idx] = max(VM(:));
[fMax, cMax] = ind2sub(size(VM), idx);
xMax = X(fMax, cMax);
yMax = Y(fMax, cMax);

% 6) Gráfico
figure;
contourf(X, Y, VM, 30, 'LineStyle','none');
colorbar;
title('Tensión de Von Mises');
xlabel('x');
ylabel('y');
axis equal; axis([-0.5 4.5 -0.5 2.5]);

% Bordes
xx = linspace(0,4,200);
hold on;
plot(xx, xx/8, 'k','LineWidth',1.3);
plot(xx, 2-xx/8,'k','LineWidth',1.3);
plot([0 0],[0 2],'k','LineWidth',1.3);
plot([4 4],[0.5 1.5],'k','LineWidth',1.3);

% Punto máximo
plot(xMax, yMax, 'ro','MarkerFaceColor','r');
text(xMax+0.1, yMax+0.1, sprintf('VM = %.3g', maxVM), 'Color','r');

fprintf('Máx Von Mises = %.6g en (%.3f , %.3f)\n', maxVM, xMax, yMax);
hold off;

13 Campo de Fuerzas

El campo de fuerzas [math]\vec{F}[/math] que actúa sobre la placa, y que es responsable del desplazamiento observado, se puede aproximar mediante la ecuación de la elasticidad lineal:

[math]\vec{F} = - \operatorname{div} \sigma[/math]

donde [math]\operatorname{div} \sigma[/math] es la divergencia de un campo tensorial. En coordenadas cartesianas, se expresa como:

[math]\operatorname{div} \sigma = (\operatorname{div} \sigma)_1 , \vec{i} + (\operatorname{div} \sigma)_2 , \vec{j} + (\operatorname{div} \sigma)3 , \vec{k}, \quad (\operatorname{div} \sigma)i = \sum{j=1}^{3} \frac{\partial \sigma{ij}}{\partial x_j}[/math]

Esta formulación permite calcular, a partir del tensor de tensiones, el campo de fuerzas internas que genera los desplazamientos de la placa.

% Evaluación del Campo de Cargas Internas
clear; clc; close all;

% 1. Generación del mallado sobre la región trapezoidal
dx = 0.1;
X = 0:dx:4;
Y = 0:dx:2;
[XX, YY] = meshgrid(X, Y);

% Definición del dominio trapezoidal
enDominio = (YY >= XX/8) & (YY <= 2 - XX/8);
XX(~enDominio) = NaN;
YY(~enDominio) = NaN;

% Parámetros elásticos
lam = 1; 
mus = 1;

% 2. Tensiones: cálculo a partir del campo de deformación
divU = YY / 20;        % Divergencia
eps_xx = YY / 20;      % Deformación xx
eps_yy = zeros(size(XX));  % Deformación yy (nula)

% Componentes del tensor de tensiones
Sxx = lam .* divU + 2 .* mus .* eps_xx;
Syy = lam .* divU + 2 .* mus .* eps_yy;
Sxy = -XX / 20;

% 3. Divergencia del tensor (fuerzas volumétricas)
% F = -∇·σ
[dSxx_dx, dSxx_dy] = gradient(Sxx, dx, dx);
[dSxy_dx, dSxy_dy] = gradient(Sxy, dx, dx);
[dSyy_dx, dSyy_dy] = gradient(Syy, dx, dx);

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

% 4. Evaluación de la magnitud máxima del campo F
magnF = sqrt(Fx.^2 + Fy.^2);
valorMax = max(magnF(:));

fprintf('--- Verificación del equilibrio ---\n');
fprintf('Máximo valor de

14 Densidad

Figura 10

%Cálculo de la Masa Total
clc; clear; close all;

% 1.Mallado
h = 0.01;
x = 0:h:4;
y = 0:h:2;
[X, Y] = meshgrid(x, y);

% 2. Placa 
Condition = (Y >= X./8) & (Y <= 2 - X./8);   % *** corregido ***

% 3. Densidad
Densidad = (4 - X) .* abs(Y);

% Densidad fuera de la placa = 0
Densidad(~Condition) = 0;

% 4. Masa
dA = h * h;
Masa_Total = sum(Densidad(:)) * dA;

% 5. Gráfica única
figure('Name','Densidad','Color','w');

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(cool); 
colorbar;

title('Distribución de Densidad d(x,y) = (4-x)|y|');
xlabel('X'); ylabel('Y'); zlabel('Densidad');
view(45,30); grid on; axis tight;
hold off;

15 Ejemplos de uso en la ingeniería

Las vigas en voladizo destacan por su forma y por la versatilidad que ofrecen, lo que las convierte en un elemento muy empleado en distintos ámbitos. Algunos de sus usos más frecuentes son:

• Arquitectura: se utilizan en balcones, terrazas, marquesinas o cubiertas de acceso. • Maquinaria: forman parte de brazos de grúas y de las palas de los aerogeneradores. • Ingeniería: se aplican en la construcción de puentes en voladizo y en diferentes componentes estructurales.

16 Bibliografía

Para la realización del trabajo nos hemos apoyado en:

• MATLAB (Creación de gráficas).
• Apuntes de clase y los proporcionados por la escuela (aportación teórica).
• Trabajos de años anteriores.
• Chat GPT y Copilot M365 (ayuda con los códigos Matlab y con la comprensión del ejercicio).