MateWiki - Contribuciones del usuario [es]

La presa de El Atazar

2024-11-27T16:04:20Z

Lara.gutierrez:

[[Categoría:Teoría de Campos]]
[[Categoría:TC24/25]]
La presa de El Atazar, ubicada en el río Lozoya, es la mayor y más importante de la Comunidad de Madrid. Inaugurada en 1972, es una presa de gravedad y arco con 134 metros de altura y una capacidad de 425 hectómetros cúbicos, siendo clave para el abastecimiento de agua potable en Madrid y su área metropolitana.

El presente trabajo tiene por objeto la visualización y representación de la geometría de la presa para hacer un posterior análisis de la estabilidad estructural y la interacción del agua con la presa, incluyendo presión y caudal.
Para su realización se empleará el software de programación y cálculo numérico Matlab.

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] |
*Cristopher Ardon Colindres
*Andrea Garcia Carrasco
*Aaron García Martín
*Lara Gutiérrez Kreutzer }}

==Representación de la presa ==

En primer lugar, se representa la superficie aguas arriba de la presa. Esta tiene una altura de 134 metros, y está definida por <math>θ ∈ [\frac{3π}{4}, \frac{5π}{4}]</math> y <math>Z ∈ [0,H]</math>.
Para su realización, se ha comenzado definiendo los parámetros básicos y discreteando el dominio con una altura de paso de h=100. Con el comando "meshgrid()" se construye una malla que permita parametrizar la superficie en coordenadas cilíndricas según la siguiente ecuación.
<center><math>r = r_{0} + b * (1 - \frac{z^2}{h^2})</math></center>
Por último, se convierte la parametrización a coordenadas cartesianas y con el comando "surf()" obtenemos la gráfica de la superficie.
A continuación, se muestra el código empleado para la obtención de la presa y la imagen resultante:
[[Archivo:fotopresa1.png|miniaturadeimagen|Representación Presa|Figura 1. Representación de la presa.]]

{{matlab|codigo=
r0 = 200; % Radio base de la presa (aproximado)
b = 35; % Curvatura del arco parabólico
H = 134; % Altura de la presa
theta_min = 3*pi/4;
theta_max = 5*pi/4;
theta = linspace(theta_min, theta_max, 100); % Ángulo en radianes
z = linspace(0, H, 100); % Altura
[Theta, Z] = meshgrid(theta, z); % Creación del mallado
R = r0 + b * (1 - (Z.^2) / H^2); % Ecuación paramétrica para r
X = R .* cos(Theta); % Conversión a coordenadas cartesiana
Y = R .* sin(Theta);
figure;
surf(X, Y, Z, 'FaceColor', 'cyan', 'EdgeColor', 'none');
xlabel('Eje X (m)');
ylabel('Eje Y (m)');
zlabel('Eje Z (m)');
title('Superficie parametrizada de la presa (aguas arriba)');
axis equal;
view(3); %Visualizamos el gráfico en tres dimensiones
grid on;
}}

==Presiones sobre la presa ==
A continuación, analizamos y visualizamos los efectos de la presión sobre la superficie de la presa mediante la representación de los campos escalares y vectoriales de presión.

===Campo escalar de presión===
El campo escalar de presiones viene dado por la función: <math>P(z)=ρgh(z)</math>. donde ρ es la densidad del agua, g es la aceleración de la gravedad, y h(z) es la profundidad del agua.
Representamos este campo para visualizar cómo varía la presión a lo largo de la superficie aguas arriba de la presa, lo que nos permite identificar las zonas de mayor y menor presión.

[[Archivo:fotopresa2.png|miniaturadeimagen|Distribución de presiones|Figura 2. Representación del campo escalar de persión sobre la presa.]]
{{matlab|codigo=
% Parámetros de presión
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)
% Cálculo de la presión
P = rho * g * (H - Z); % Presión en función de z
% Gráfica de la superficie con mapa de colores para la presión
figure;
surf(X, Y, Z, P, 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Presión sobre la superficie de la presa');
colorbar; % Barra de colores para indicar magnitudes de presión
colormap(jet); % Esquema de colores
axis equal;
view(3);
grid on;
}}
<center> '''INTERPRETACIÓN DEL CAMPO ESCALAR DE PERSIÓN''' </center>
En la imagen se observan dos gamas de colores diferenciadas: una primera, correspondiente a tonos fríos (azul), que representa las zonas de menor presión, y una segunda, compuesta por tonos cálidos (amarillo), asociada a las regiones de mayor presión. Es coherente con el comportamiento hidrostático que los valores más altos de presión se localicen en la base de la presa y disminuyan progresivamente con la altura.

===Campo vectorial de la fuerza de presión===
En segundo lugar, se representa el campo vectorial de la fuerza de presión tanto sobre el paramento aguas arriba de la presa como en un plano que la corta verticalmente. Esto permite visualizar cómo la presión del agua genera fuerzas perpendiculares a la superficie de la presa, cuya intensidad aumenta con la profundidad (mayor presión en las zonas más profundas). Además, la representación en el plano de corte proporciona una representación detallada de la distribución de las fuerzas, facilitando un análisis preciso de su comportamiento a lo largo de la profundidad y en diferentes secciones de la presa.

[[Archivo:fotopresa3.png|miniaturadeimagen|Representación Presa|Figura 3. Representación del campo escalar de presiones aguas arriba.]]
[[Archivo:fotopresa31.png|miniaturadeimagen|Representación Presa|Figura 3.1. Representación del campo escalar de presiones en un plano vertical.]]
{{matlab|codigo=
% Derivadas numéricas para obtener vectores tangentes
[Rx_theta, Rx_z] = gradient(X);
[Ry_theta, Ry_z] = gradient(Y);
[Rz_theta, Rz_z] = gradient(Z);
% Producto cruzado de vectores tangentes para obtener el vector normal
Nx = Ry_theta .* Rz_z - Rz_theta .* Ry_z;
Ny = Rz_theta .* Rx_z - Rx_theta .* Rz_z;
Nz = Rx_theta .* Ry_z - Ry_theta .* Rx_z;
% Magnitud del vector normal
N_magnitude = sqrt(Nx.^2 + Ny.^2 + Nz.^2);
% Vector normal unitario
Nx_unit = Nx ./ N_magnitude;
Ny_unit = Ny ./ N_magnitude;
Nz_unit = Nz ./ N_magnitude;
% Campo de fuerza de presión
Fx = -P .* Nx_unit;
Fy = -P .* Ny_unit;
Fz = -P .* Nz_unit;
% Representación del campo vectorial sobre la superficie
figure;
quiver3(X, Y, Z, Fx, Fy, Fz, 0.5, 'Color', 'yellow'); % Escala ajustable con el factor 2
hold on;
surf(X, Y, Z, P, 'EdgeColor', 'none', 'FaceAlpha',1); % Superficie semitransparente
colorbar;
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Campo vectorial de la fuerza de presión sobre la presa');
view(3);
grid on;
% Fijamos theta = 0 (corte longitudinal)
theta_cut = 0; % Corte en el plano x-z
X_cut = X(:, 51); % Extraemos el corte longitudinal (theta cerca de 0)
Z_cut = Z(:, 51); % Correspondiente en altura
P_cut = P(:, 51); % Presión en el plano
% Vectores normales en el corte
Nx_cut = Nx(:, 51); % Componente x del vector normal
Nz_cut = Nz(:, 51); % Componente z del vector normal
N_magnitude_cut = sqrt(Nx_cut.^2 + Nz_cut.^2);
% Normalización del vector normal
Nx_unit_cut = Nx_cut ./ N_magnitude_cut;
Nz_unit_cut = Nz_cut ./ N_magnitude_cut;
% Campo de fuerza de presión en el corte
Fx_cut = -P_cut .* Nx_unit_cut;
Fz_cut = -P_cut .* Nz_unit_cut;
% Gráfica del campo vectorial en el corte
figure;
quiver(X_cut, Z_cut, Fx_cut, Fz_cut, 'b', 'LineWidth', 1.5); % Vectores de fuerza
hold on;
plot(X_cut, Z_cut, 'k-', 'LineWidth', 2); % Contorno de la presa en el plano
xlabel('X (m)');
ylabel('Z (m)');
title('Campo de fuerza de presión en el plano longitudinal');
grid on;
}}

<center> '''INTERPRETACIÓN DEL CAMPO VECTORIAL DE PRESIÓN''' </center>

Nuevamente, los resultados obtenidos coinciden con lo esperado. Las presiones más altas se registran en la parte inferior de la presa, representadas en color amarillo, mientras que las más bajas se encuentran en la parte superior, en color azul. De esta manera, se observa como la presión aumenta conforme ascendemos de arriba hacia abajo.

==Estudio de la trayectoria de una gota==
===Representación de la trayectoria de la gota===
[[Archivo:fotopresa4.png|miniaturadeimagen|Representación Presa|Figura 4. Representación de la gota.]]
{{matlab|codigo=

% Parámetros
theta = deg2rad(15); % Ángulo de salida en radianes
g = 9.81; % Aceleración de la gravedad (m/s^2)
Hc = 25; % Altura inicial (m)

% Velocidad inicial (previamente calculada)
v0 = sqrt(2 * g * Hc);

% Funciones de posición
t = linspace(0, 5, 1000); % Tiempo (ajustar si es necesario)
x = v0 * cos(theta) * t;
y = Hc + v0 * sin(theta) * t - 0.5 * g * t.^2;

% Encontrar el tiempo cuando y(t) = 0 (impacto con el suelo)
t_ground = fzero(@(t) Hc + v0 * sin(theta) * t - 0.5 * g * t^2, [0, 10]);
x_ground = v0 * cos(theta) * t_ground; % Alcance horizontal

% Gráfica de la trayectoria
figure;
plot(x, y, 'b', 'LineWidth', 1.5);
hold on;
plot(x_ground, 0, 'ro', 'MarkerSize', 8, 'DisplayName', 'Impacto');
xlabel('Distancia horizontal (m)');
ylabel('Altura (m)');
title('Trayectoria de la gota de agua');
grid on;
legend;
xlim([0, x_ground + 10]);
ylim([0, Hc + 5]);
}}
===Representación de los campos tangente y normal===
[[Archivo:fotopresa5.png|miniaturadeimagen|Representación Presa|Figura 5. Representación de los campos tangente y normal.]]
{{matlab|codigo=
% Parámetros
theta = deg2rad(15);
g = 9.81;
Hc = 25;
v0 = sqrt(2 * g * Hc);

% Trayectoria
t = linspace(0, 5, 500); % Tiempo
x = v0 * cos(theta) * t;
y = Hc + v0 * sin(theta) * t - 0.5 * g * t.^2;

% Velocidades (derivadas de la posición)
vx = v0 * cos(theta) * ones(size(t)); % dx/dt
vy = v0 * sin(theta) - g * t; % dy/dt
speed = sqrt(vx.^2 + vy.^2); % Magnitud de la velocidad

% Tangente unitario
Tx = vx ./ speed;
Ty = vy ./ speed;

% Aceleraciones (derivadas de las velocidades)
ax = zeros(size(t)); % dvx/dt = 0
ay = -g * ones(size(t)); % dvy/dt
a_magnitude = sqrt(ax.^2 + ay.^2); % Magnitud de la aceleración

% Normal unitario
Nx = (ax - Tx .* (ax .* Tx + ay .* Ty)) ./ a_magnitude;
Ny = (ay - Ty .* (ax .* Tx + ay .* Ty)) ./ a_magnitude;

% Graficar trayectoria
figure;
plot(x, y, 'b', 'LineWidth', 1.5); hold on;

% Campos tangente y normal en puntos específicos
num_points = 20; % Número de vectores a graficar
indices = round(linspace(1, length(t), num_points));
quiver(x(indices), y(indices), Tx(indices), Ty(indices), 0.3, 'r', 'LineWidth', 1.5, 'DisplayName', 'Tangente');
quiver(x(indices), y(indices), Nx(indices), Ny(indices), 0.3, 'g', 'LineWidth', 1.5, 'DisplayName', 'Normal');

% Detalles de la gráfica
xlabel('Distancia horizontal (m)');
ylabel('Altura (m)');
title('Campos Tangente y Normal sobre la trayectoria');
legend('Trayectoria', 'Tangente', 'Normal');
grid on;
axis equal;
}}
===Animación de los vectores sobre la curva de la trayectoria===

{{matlab|codigo=
% Parámetros de la animación
t_anim = linspace(0, t_ground, 200); % Tiempo para animación
x_anim = v0 * cos(theta) * t_anim;
y_anim = Hc + v0 * sin(theta) * t_anim - 0.5 * g * t_anim.^2;

% Velocidades y aceleraciones en los puntos de la animación
vx_anim = v0 * cos(theta) * ones(size(t_anim));
vy_anim = v0 * sin(theta) - g * t_anim;
speed_anim = sqrt(vx_anim.^2 + vy_anim.^2);

% Aceleración constante en y
ax_anim = zeros(size(t_anim));
ay_anim = -g * ones(size(t_anim));

% Crear la figura
figure;
hold on;
plot(x, y, 'b', 'LineWidth', 1.5, 'DisplayName', 'Trayectoria'); % Trayectoria completa
xlabel('Distancia horizontal (m)');
ylabel('Altura (m)');
title('Animación: Gota de Agua');
grid on;
axis equal;
xlim([0, max(x)]);
ylim([0, Hc + 5]);

% Añadir marcador para la gota
gota = plot(x_anim(1), y_anim(1), 'ro', 'MarkerSize', 10, 'DisplayName', 'Gota');

% Añadir vectores de velocidad y aceleración
quiver_vel = quiver(x_anim(1), y_anim(1), vx_anim(1), vy_anim(1), 0.3, 'r', 'LineWidth', 1.5, 'MaxHeadSize', 1, 'DisplayName', 'Velocidad');
quiver_acc = quiver(x_anim(1), y_anim(1), ax_anim(1), ay_anim(1), 0.3, 'g', 'LineWidth', 1.5, 'MaxHeadSize', 1, 'DisplayName', 'Aceleración');

legend;

% Animación
for i = 1:length(t_anim)
% Actualizar marcador
set(gota, 'XData', x_anim(i), 'YData', y_anim(i));

% Actualizar vectores
set(quiver_vel, 'XData', x_anim(i), 'YData', y_anim(i), ...
'UData', vx_anim(i), 'VData', vy_anim(i));
set(quiver_acc, 'XData', x_anim(i), 'YData', y_anim(i), ...
'UData', ax_anim(i), 'VData', ay_anim(i));

% Pausa para visualizar
pause(0.05);
end
}}
==Caudal volumétrico==
{{matlab|codigo=
% Parámetros
A = 1100; % Área de la compuerta (m^2)
g = 9.81; % Aceleración de la gravedad (m/s^2)
Hc = 25; % Altura de salida del agua (m)

% Velocidad de salida (Torricelli)
v0 = sqrt(2 * g * Hc);

% Caudal volumétrico
Q = (A * v0)/1000;

% Mostrar resultados
fprintf('Velocidad de salida (v0): %.2f m/s\n', v0);
fprintf('Caudal volumétrico (Q): %.2f m^3/s\n', Q);
}}
Utilizando este código nos dan los resultados pedidos, la velocidad de salida es 22,15 m/s y el caudal volumétrico es 24,36 m^3/s.
==Fuerza de presión total y la presión por unidad de superficie==
Con los datos de curvatura simple y doble curvatura creamos un código en matlab para que nos de el resultado de la fuerza y la presión y poder compararlos.
{{matlab|codigo=
% Parámetros de la presa
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)
H = 134; % Altura de la presa (m)
r0 = 80; % Radio base (m)
b1 = 35; % Curvatura doble
b0 = 0; % Curvatura simple
theta_range = linspace(-pi/4, pi/4, 100); % Ángulo

% Definir función de radio (diferentes curvaturas)
r_1 = @(z) r0 + b1 * (1 - (z / H)^2);
r_0 = @(z) r0;

% Cálculo de área y fuerza (doble curvatura)
z_range = linspace(0, H, 100); % Alturas
F_1 = 0;
A_1 = 0;
for z = z_range
r = r_1(z);
dA = 2 * pi * r * H / length(z_range); % Aproximación diferencial
P = rho * g * (H - z); % Presión a esa profundidad
F_1 = F_1 + P * dA; % Sumar contribución
A_1 = A_1 + dA; % Sumar área
end
p_s_1 = F_1 / A_1; % Presión por unidad de área

% Cálculo de área y fuerza (curvatura simple)
F_0 = 0;
A_0 = 0;
for z = z_range
r = r_0(z);
dA = 2 * pi * r * H / length(z_range); % Aproximación diferencial
P = rho * g * (H - z); % Presión a esa profundidad
F_0 = F_0 + P * dA; % Sumar contribución
A_0 = A_0 + dA; % Sumar área
end
p_s_0 = F_0 / A_0; % Presión por unidad de área

% Resultados
fprintf('Doble curvatura:\n');
fprintf(' - Fuerza total: %.2e N\n', F_1);
fprintf(' - Presión por unidad de superficie: %.2e Pa\n\n', p_s_1);

fprintf('Curvatura simple:\n');
fprintf(' - Fuerza total: %.2e N\n', F_0);
fprintf(' - Presión por unidad de superficie: %.2e Pa\n', p_s_0);
}}
En el caso de la doble curvatura, b=35, la fuerza total es de 6,04*10^10 N y su presión por unidad de superficie es de 6,95*10^5 Pa.
En la de curvatura simple, b=0, la fuerza total es de 4,43*10^10 N y la presión de 6,57*10^5 Pa.
Por lo tanto soportaría más presión la configuración de doble curvatura.

==Tipos de presa, estabilidad y materiales==

La presa de El Atazar

2024-11-26T20:11:32Z

Lara.gutierrez:

La presa de El Atazar

2024-11-26T19:44:53Z

Lara.gutierrez:

La presa de El Atazar

2024-11-26T19:03:50Z

Lara.gutierrez:

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] |
*Cristopher Ardon Colindres
*Andrea Garcia Carrasco
*Aaron García Martín
*Lara Gutiérrez Kreutzer }}

La presa de El Atazar, ubicada en el río Lozoya, es la mayor y más importante de la Comunidad de Madrid. Inaugurada en 1972, es una presa de gravedad y arco con 134 metros de altura y una capacidad de 425 hectómetros cúbicos, siendo clave para el abastecimiento de agua potable en Madrid y su área metropolitana.

El presente trabajo tiene por objeto la visualización y representación de la geometría de la presa para hacer un posterior análisis de la estabilidad estructural y la interacción del agua con la presa, incluyendo presión y caudal.
Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la presa ==

Se quiere obtener una superficie 3D que representa la cara de aguas arriba de la presa con doble curvatura.
Para su realización, se ha comenzado definiendo los parámetros básicos y discreteando el dominio, dividiendo el dominio de ángulos y altura en 100. Con el comando "meshgrid()" se construye una malla que permita parametrizar la superficie en coordenadas cilíndricas según la siguiente ecuación.

<math>r = r+b(1-(z^2/h^2))</math>
Por último, se convierte la parametrizacion a coordenadas cartesianas y con el comando "surf()" obtenemos la gráfica de la superficie.
{{matlab|codigo=
clc
% Parámetros de la presa
r0 = 200; % Radio base de la presa (aproximado)
b = 35; % Curvatura del arco parabólico
H = 134; % Altura de la presa
theta_min = -pi/4;
theta_max = pi/4;

% Discretización del dominio
theta = linspace(theta_min, theta_max, 100); % Ángulo en radianes
z = linspace(0, H, 100); % Altura

% Malla para parametrización
[Theta, Z] = meshgrid(theta, z);

% Ecuación paramétrica para r
R = r0 + b * (1 - (Z.^2) / H^2);

% Conversión a coordenadas cartesianas
X = R .* cos(Theta);
Y = R .* sin(Theta);

% Gráfica de la superficie
figure;
surf(X, Y, Z, 'FaceColor', 'cyan', 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Superficie parametrizada de la presa (aguas arriba)');
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa1.png|500px|centre|Representación Presa|]]

==Distribución de presiones sobre la presa ==
{{matlab|codigo=
% Parámetros de presión
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)

% Cálculo de la presión
P = rho * g * (H - Z); % Presión en función de z

% Gráfica de la superficie con mapa de colores para la presión
figure;
surf(X, Y, Z, P, 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Presión sobre la superficie de la presa');
colorbar; % Barra de colores para indicar magnitudes de presión
colormap(jet); % Esquema de colores
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa2.png|500px|centre|Distribución de presiones|]]

[[Categoría:Teoría de Campos]]
[[Categoría:TC24/25]]

La presa de El Atazar

2024-11-26T10:11:59Z

Lara.gutierrez: /* Representación de la presa */

La presa de El Atazar

2024-11-26T10:10:23Z

Lara.gutierrez: /* Representación de la presa */

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] |
*Cristopher Ardon Colindres
*Andrea Garcia Carrasco
*Aaron García Martín
*Lara Gutiérrez Kreutzer }}

La presa de El Atazar, ubicada en el río Lozoya, es la mayor y más importante de la Comunidad de Madrid. Inaugurada en 1972, es una presa de gravedad y arco con 134 metros de altura y una capacidad de 425 hectómetros cúbicos, siendo clave para el abastecimiento de agua potable en Madrid y su área metropolitana.

El presente trabajo tiene por objeto la visualización y representación de la geometría de la presa para hacer un posterior análisis de la estabilidad estructural y la interacción del agua con la presa, incluyendo presión y caudal.
Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la presa ==

Se quiere obtener una superficie 3D que representa la cara de aguas arriba de la presa con doble curvatura.
Para su realización, se ha comenzado definiendo los parámetros básicos y discreteando el dominio, dividiendo el dominio de ángulos y altura en 100. Con el comando "meshgrid()" se construye una malla que permita parametrizar la superficie en coordenadas cilíndricas según la siguiente ecuación.

Por último, se convierte la parametrizacion a coordenadas cartesianas y con el comando "surf()" obtenemos la gráfica de la superficie.
{{matlab|codigo=
clc
% Parámetros de la presa
r0 = 200; % Radio base de la presa (aproximado)
b = 35; % Curvatura del arco parabólico
H = 134; % Altura de la presa
theta_min = -pi/4;
theta_max = pi/4;

% Discretización del dominio
theta = linspace(theta_min, theta_max, 100); % Ángulo en radianes
z = linspace(0, H, 100); % Altura

% Malla para parametrización
[Theta, Z] = meshgrid(theta, z);

% Ecuación paramétrica para r
R = r0 + b * (1 - (Z.^2) / H^2);

% Conversión a coordenadas cartesianas
X = R .* cos(Theta);
Y = R .* sin(Theta);

% Gráfica de la superficie
figure;
surf(X, Y, Z, 'FaceColor', 'cyan', 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Superficie parametrizada de la presa (aguas arriba)');
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa1.png|500px|centre|Representación Presa|]]

==Distribución de presiones sobre la presa ==
{{matlab|codigo=
% Parámetros de presión
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)

% Cálculo de la presión
P = rho * g * (H - Z); % Presión en función de z

% Gráfica de la superficie con mapa de colores para la presión
figure;
surf(X, Y, Z, P, 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Presión sobre la superficie de la presa');
colorbar; % Barra de colores para indicar magnitudes de presión
colormap(jet); % Esquema de colores
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa2.png|500px|centre|Distribución de presiones|]]

La presa de El Atazar

2024-11-26T10:10:06Z

Lara.gutierrez: /* Representación de la presa */

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] |
*Cristopher Ardon Colindres
*Andrea Garcia Carrasco
*Aaron García Martín
*Lara Gutiérrez Kreutzer }}

La presa de El Atazar, ubicada en el río Lozoya, es la mayor y más importante de la Comunidad de Madrid. Inaugurada en 1972, es una presa de gravedad y arco con 134 metros de altura y una capacidad de 425 hectómetros cúbicos, siendo clave para el abastecimiento de agua potable en Madrid y su área metropolitana.

El presente trabajo tiene por objeto la visualización y representación de la geometría de la presa para hacer un posterior análisis de la estabilidad estructural y la interacción del agua con la presa, incluyendo presión y caudal.
Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la presa ==

Se quiere obtener una superficie 3D que representa la cara de aguas arriba de la presa con doble curvatura.
Para su realización, se ha comenzado definiendo los parámetros básicos y discreteando el dominio, dividiendo el dominio de ángulos y altura en 100. Con el comando "meshgrid()'' se construye una malla que permita parametrizar la superficie en coordenadas cilíndricas según la siguiente ecuación.

Por último, se convierte la parametrizacion a coordenadas cartesianas y con el comando "surf()" obtenemos la gráfica de la superficie.
{{matlab|codigo=
clc
% Parámetros de la presa
r0 = 200; % Radio base de la presa (aproximado)
b = 35; % Curvatura del arco parabólico
H = 134; % Altura de la presa
theta_min = -pi/4;
theta_max = pi/4;

% Discretización del dominio
theta = linspace(theta_min, theta_max, 100); % Ángulo en radianes
z = linspace(0, H, 100); % Altura

% Malla para parametrización
[Theta, Z] = meshgrid(theta, z);

% Ecuación paramétrica para r
R = r0 + b * (1 - (Z.^2) / H^2);

% Conversión a coordenadas cartesianas
X = R .* cos(Theta);
Y = R .* sin(Theta);

% Gráfica de la superficie
figure;
surf(X, Y, Z, 'FaceColor', 'cyan', 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Superficie parametrizada de la presa (aguas arriba)');
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa1.png|500px|centre|Representación Presa|]]

==Distribución de presiones sobre la presa ==
{{matlab|codigo=
% Parámetros de presión
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)

% Cálculo de la presión
P = rho * g * (H - Z); % Presión en función de z

% Gráfica de la superficie con mapa de colores para la presión
figure;
surf(X, Y, Z, P, 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Presión sobre la superficie de la presa');
colorbar; % Barra de colores para indicar magnitudes de presión
colormap(jet); % Esquema de colores
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa2.png|500px|centre|Distribución de presiones|]]

La presa de El Atazar

2024-11-26T10:09:26Z

Lara.gutierrez: /* Representación de la presa */

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] |
*Cristopher Ardon Colindres
*Andrea Garcia Carrasco
*Aaron García Martín
*Lara Gutiérrez Kreutzer }}

La presa de El Atazar, ubicada en el río Lozoya, es la mayor y más importante de la Comunidad de Madrid. Inaugurada en 1972, es una presa de gravedad y arco con 134 metros de altura y una capacidad de 425 hectómetros cúbicos, siendo clave para el abastecimiento de agua potable en Madrid y su área metropolitana.

El presente trabajo tiene por objeto la visualización y representación de la geometría de la presa para hacer un posterior análisis de la estabilidad estructural y la interacción del agua con la presa, incluyendo presión y caudal.
Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la presa ==

Se quiere obtener una superficie 3D que representa la cara de aguas arriba de la presa con doble curvatura.
Para su realización, se ha comenzado definiendo los parámetros básicos y discreteando el dominio, dividiendo el dominio de ángulos y altura en 100. Con el comando 'meshgrid()'' se construye una malla que permita parametrizar la superficie en cordenadas cilíndricas según la siguiente ecuación.

Por último, se convierte la parametrizacion a coordenadas cartesianas y con el comando "surf()" obtenemos la gráfica de la superficie.
{{matlab|codigo=
clc
% Parámetros de la presa
r0 = 200; % Radio base de la presa (aproximado)
b = 35; % Curvatura del arco parabólico
H = 134; % Altura de la presa
theta_min = -pi/4;
theta_max = pi/4;

% Discretización del dominio
theta = linspace(theta_min, theta_max, 100); % Ángulo en radianes
z = linspace(0, H, 100); % Altura

% Malla para parametrización
[Theta, Z] = meshgrid(theta, z);

% Ecuación paramétrica para r
R = r0 + b * (1 - (Z.^2) / H^2);

% Conversión a coordenadas cartesianas
X = R .* cos(Theta);
Y = R .* sin(Theta);

% Gráfica de la superficie
figure;
surf(X, Y, Z, 'FaceColor', 'cyan', 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Superficie parametrizada de la presa (aguas arriba)');
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa1.png|500px|centre|Representación Presa|]]

==Distribución de presiones sobre la presa ==
{{matlab|codigo=
% Parámetros de presión
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)

% Cálculo de la presión
P = rho * g * (H - Z); % Presión en función de z

% Gráfica de la superficie con mapa de colores para la presión
figure;
surf(X, Y, Z, P, 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Presión sobre la superficie de la presa');
colorbar; % Barra de colores para indicar magnitudes de presión
colormap(jet); % Esquema de colores
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa2.png|500px|centre|Distribución de presiones|]]

La presa de El Atazar

2024-11-26T10:08:39Z

Lara.gutierrez: /* Representación de la presa */

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] |
*Cristopher Ardon Colindres
*Andrea Garcia Carrasco
*Aaron García Martín
*Lara Gutiérrez Kreutzer }}

La presa de El Atazar, ubicada en el río Lozoya, es la mayor y más importante de la Comunidad de Madrid. Inaugurada en 1972, es una presa de gravedad y arco con 134 metros de altura y una capacidad de 425 hectómetros cúbicos, siendo clave para el abastecimiento de agua potable en Madrid y su área metropolitana.

El presente trabajo tiene por objeto la visualización y representación de la geometría de la presa para hacer un posterior análisis de la estabilidad estructural y la interacción del agua con la presa, incluyendo presión y caudal.
Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la presa ==

Se quiere obtener una superficie 3D que representa la cara de aguas arriba de la presa con doble curvatura.
Para su realización, se ha comenzado definiendo los parámetros básicos y discreteando el dominio, dividiendo el dominio de ángulos y altura en 100. Con el comando 'meshgrid()'' se construye una malla que permita parametrizar la superficie en cordenadas cilíndricas según la siguiente ecuación.

PO último, se convierte la parametrizacion a coordenadas cartesianas y con el comando "surf()" obtenemos la gráfica de la superficie.
clc
% Parámetros de la presa
r0 = 200; % Radio base de la presa (aproximado)
b = 35; % Curvatura del arco parabólico
H = 134; % Altura de la presa
theta_min = -pi/4;
theta_max = pi/4;

% Discretización del dominio
theta = linspace(theta_min, theta_max, 100); % Ángulo en radianes
z = linspace(0, H, 100); % Altura

% Malla para parametrización
[Theta, Z] = meshgrid(theta, z);

% Ecuación paramétrica para r
R = r0 + b * (1 - (Z.^2) / H^2);

% Conversión a coordenadas cartesianas
X = R .* cos(Theta);
Y = R .* sin(Theta);

% Gráfica de la superficie
figure;
surf(X, Y, Z, 'FaceColor', 'cyan', 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Superficie parametrizada de la presa (aguas arriba)');
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa1.png|500px|centre|Representación Presa|]]

==Distribución de presiones sobre la presa ==
{{matlab|codigo=
% Parámetros de presión
rho = 1000; % Densidad del agua (kg/m^3)
g = 9.81; % Gravedad (m/s^2)

% Cálculo de la presión
P = rho * g * (H - Z); % Presión en función de z

% Gráfica de la superficie con mapa de colores para la presión
figure;
surf(X, Y, Z, P, 'EdgeColor', 'none');
xlabel('X (m)');
ylabel('Y (m)');
zlabel('Z (m)');
title('Presión sobre la superficie de la presa');
colorbar; % Barra de colores para indicar magnitudes de presión
colormap(jet); % Esquema de colores
axis equal;
view(3);
grid on;
}}
[[Archivo:fotopresa2.png|500px|centre|Distribución de presiones|]]

La presa de El Atazar

2024-11-26T09:39:14Z

Lara.gutierrez:

La presa de El Atazar

2024-11-26T09:37:44Z

Lara.gutierrez:

La presa de El Atazar

2024-11-26T09:37:29Z

Lara.gutierrez:

La presa de El Atazar

2024-11-26T09:16:35Z

Lara.gutierrez:

{{ TrabajoED | La presa de El Atazar. Grupo 31 | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] | Cristopher Ardon Colindres Andrea Garcia Carrasco Aaron García Martín Lara Gutiérrez Kreutzer }}

La presa de El Atazar

2024-11-26T09:11:46Z

Lara.gutierrez: Página creada con «{{ TrabajoED | Deformaciones de una placa plana. Grupo 6-A | Teoría de Campos|2024-25 | Nuestros nombres }}»

{{ TrabajoED | Deformaciones de una placa plana. Grupo 6-A | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC24/25|2024-25]] | Nuestros nombres }}

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-14T22:17:06Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]
El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuerza determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana. Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:
[[Archivo:Mallado16a.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis equal
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas, que representa la variación de temperatura a lo largo de la placa. Usaremos el siguiente código:
[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN DEL CAMPO DE TEMPERATURAS''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|350px|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|400px|Figura 5. Ampliación Gradiente de Temperatura]]

<center> '''INTERPRETACIÓN DEL GRADIENTE DEL CAMPO DE TEMPERATURAS''' </center>

El gradiente apunta a los puntos de la gráfica a los cuales la gráfica tiene un mayor incremento de temperatura.

==Ley de Fourier==

De acuerdo a la Ley de Fourier la energía calorífica Q viaja de acuerdo a la fórmula
Q = −κ∇T,
donde κ es la constante de conductividad térmica de la placa que supondremos κ = 1.
[[Archivo:Ley_de_Fourier16a1.png|miniaturadeimagen|400px|Figura 5. Ley de Fourier]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
k=1; %Constante de conductividad térmica
dx=-(6.*(X-1))./(1+(X-1).^2);
dy=-(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Ley de Fourier");
hold off
}}

<center> '''INTERPRETACIÓN DE LA ENERGÍA CALORÍFICA''' </center>
Podemos apreciar la similitud con el gradiente. Según la Ley de Fourier el flujo de transferencia de calor es proporcional y de sentido contrario al gradiente de temperatura en esa dirección.

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación:
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (\pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Siendo <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math>

Por lo que:
<center><math>\vec{u}(x, y)=\frac{x}{3}sin (\frac{\pi*y}{12})\vec{i}.</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

[[Archivo:Campodedesplazamientos16a.png|miniaturadeimagen|derecha|425px|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
axis equal
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

<center> '''INTERPRETACIÓN DEL CAMPO DE VECTORES''' </center>

El campo de vectores queda representado en color rojo sobre la malla del sólido. Puesto que el campo de vectores se intensifica lateralmente siendo máximo en los cantos, podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

==Comparación de la placa antes y después del desplazamiento==
La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después. Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando surf(). A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando hold on y hold of, que se muestre con líneas el sólido deformado.
[[Archivo:Comparacion16a.png|derecha|miniaturadeimagen|400px|Figura 7. Sólido antes de la deformación y después.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia sera positiva, y si tiene "sumideros" sera negativa.

Calculamos la divergencia de:

<center><math>\vec{u}(x, y)=\frac{x}{3}sin (\frac{\pi*y}{12})\vec{i}.</math></center>

Entonces:

<center><math>\nabla ·\vec u = \frac{\partial u_1}{\partial x} + \frac{\partial u_2}{\partial y} = \frac{1}{3}sin (\frac{\pi*y}{12}) </math></center>

Utilizaremos el codigo que se muestra a continuación para obtener los valores máximos y mínimos de la divergencia.

[[Archivo:figura6 equivocacion.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]
[[Archivo:figura6 equivocacion2.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
%Dibujo de la divergencia
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))
}}

'''En la grafica se puede apreciar que la divergencia es de 0.333 y la mínima es tambien la nula, es decir, 0.'''

== Rotacional del sólido ==

En este siguiente apartado calcularemos el rotacional y a continuación lo representaremos.

<center><math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = -\frac{\pi*x}{36}*cos(\frac{pi*y}{12})\vec{k} </math>.</center>

[[Archivo:Rot16a.png|500px|miniaturadeimagen|Módulo del rotacional]]
{{matlab|codigo=
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=-((Mx.*pi)/36).*cos((pi.*My)/12)
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1,1,0,12]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y')

}}

<center> '''INTERPRETACIÓN DEL ROTACIONAL''' </center>
Como podemos observar los puntos que sufren un mayor rotacional son aquellos representados en color amarillo, estos tendrán una mayor capacidad de giro ya que el rotacional nos indica la capacidad que tienen los distintos puntos de nuestra placa para girar sobre otro punto determinado.

==Tensiones en las direcciones <math>\vec i </math>, <math>\vec j </math>, <math>\vec k </math> ==
Definamos <math>e(\vec{u}) = (∇\vec{u} + \triangledown \vec{u}^{t})/2</math>, la parte simétrica del tensor gradiente de <math>\vec{u}</math> conocido como tensor de deformaciones. En un medio elástico lineal, isótropo y homogéneo los desplazamientos
permiten escribir el tensor de tensiones <math>σ_{ij}</math> a través de la fórmula <math>σ = λ∇ · \vec{u} 1 + 2 μe</math>,
donde λ y μ son los conocidos como coeficientes de Lamé que dependen de las propiedades elásticas de cada material. A pesar de que los desplazamientos son planos (es decir <math>\vec{u}</math> no tiene componente en la dirección de <math>\vec{k}</math>) las tensiones no tienen por qué ser planas y puede haber tensiones en la dirección ortogonal al plano de la placa. Tomando <math>λ = μ = 1</math>. Asi que pasamos a dibujar las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i}·σ·\vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j}·σ·\vec{j}</math> y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k}·σ·\vec{k}</math>.

Primero para calcular e, debemos calcular el gradiente de <math>e(\vec{u})</math> y su transpuesto.
<center><math>\vec{u}(x, y)=\frac{x}{3}sin (\frac{\pi*y}{12})\vec{i}.</math></center>

<math> \nabla\vec u=
\begin{pmatrix}\frac {\partial u_1}{\partial x} & \frac{\partial u_1}{\partial y} & \frac{\partial u_1}{\partial z} \\
\frac{\partial u_2}{\partial x} & \frac{\partial u_2}{\partial y} & \frac{\partial u_2}{\partial z} \\
\frac{\partial u_3}{\partial x} & \frac{\partial u_3}{\partial y} & \frac{\partial u_3}{\partial z}\end{pmatrix} =
\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
0 & 0 & 0\\
0 & 0 & 0\end{pmatrix}
</math>

Hallamos su transpuesta.

<math>\nabla \vec u ^t=
\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & 0 & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) & 0 & 0 \\
0 & 0 & 0\end{pmatrix}
</math>

Encontramos <math>e(\vec{u})</math> aplicando la fórmula.

<math>e(\vec{u}) =
\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & \frac{πx}{72}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{72}cos(\frac{π}{12}y) & 0 & 0 \\
0 & 0 & 0\end{pmatrix}
</math>

Teniendo todos los datos, ya podemos calcular nuestro tensor de tensiones <math>σ_{ij}</math> a través de la fórmula <math>σ = λ∇ · \vec{u} 1 + 2 μe</math>.

<math>σ = λ\frac{1}{3}sin(\frac{π}{12}y)\begin{pmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{pmatrix}+2μ\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & \frac{πx}{72}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{72}cos(\frac{π}{12}y) & 0 & 0 \\
0 & 0 & 0\end{pmatrix}</math>

<math>σ = \begin{pmatrix}\frac{1}{3}sin(\frac{π}{12})(2μ+λ) & \frac{πx}{36}cos(\frac{π}{12}y)(μ) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y)(μ) &\frac{1}{3}sin(\frac{π}{12}y)(λ) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)(λ)\end{pmatrix}</math>

Teniendo en cuenta que λ=μ=1, obtenemos:

<math>σ = \begin{pmatrix}sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}</math>

Por último se procede al cálculo de las tensiones normales a la dirección que marca cada vector de la base ortonormal orientada positivamente adoptada.
Dichas tensiones son las que se encuentran en los elementos de la diagonal de la matriz <math>\sigma_{ij}</math>:

=== Tensiones normales en dirección del eje <math>\vec i </math> ===

Aplicamos: <math>\vec i \cdot \sigma_{ij} \cdot \vec i = sin(\frac{π}{12}y)</math>

[[Archivo:Tension normal en i.png|400px|miniaturadeimagen|right|Figura 11. Tension Normal en i]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
%Generación de la retícula rectangular
[xx,yy]=meshgrid(x,y);
%tensiones normales en la dirección normal del eje i
tni=sin((pi.*yy)/12);
tnj=(1/3).*sin((pi.*yy)/12);
tnk=(1/3).*sin((pi.*yy)/12);
%Representación tensiones normales
figure
surf(xx,yy,tni)
shading flat
axis equal
colorbar
axis([-1.5,2,-1,15]);
title('Tensión normal en dirección i');
xlabel('Eje X');
ylabel('Eje Y');
view(2);
}}

=== Tensiones normales en dirección del eje <math>\vec j </math> ===

Aplicamos: <math>\vec j \cdot \sigma_{ij} \cdot \vec j = \frac{1}{3}sin(\frac{π}{12}y)</math>

[[Archivo:Tension normal en j.png|400px|miniaturadeimagen|right|Figura 12. Tension Normal en j]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
%Generación de la retícula rectangular
[xx,yy]=meshgrid(x,y);
%tensiones normales en la dirección normal del eje j
tni=sin((pi.*yy)/12);
tnj=(1/3).*sin((pi.*yy)/12);
tnk=(1/3).*sin((pi.*yy)/12);
surf(xx,yy,tnj)
shading flat
axis equal
colorbar
axis([-1.5,2,-1,15]);
title('Tensión normal en dirección j');
xlabel('Eje X');
ylabel('Eje Y');
view(2);
}}

=== Tensiones normales en dirección del eje <math>\vec k </math> ===

Aplicamos: <math>\vec k \cdot \sigma_{ij} \cdot \vec k = \frac{1}{3}sin(\frac{π}{12}y)</math>

[[Archivo:Tension normal en k1.png|400px|miniaturadeimagen|right|Figura 13. Tension Normal en k]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
%Generación de la retícula rectangular
[xx,yy]=meshgrid(x,y);
%tensiones normales en la dirección normal del eje k
tni=sin((pi.*yy)/12);
tnj=(1/3).*sin((pi.*yy)/12);
tnk=(1/3).*sin((pi.*yy)/12);
surf(xx,yy,tnk)
shading flat
axis equal
colorbar
axis([-1.5,2,-1,15]);
title('Tensión normal en dirección k');
xlabel('Eje X');
ylabel('Eje Y');
view(2);
}}

==Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>==

Sea <math>\vec{T}</math> la tensión tangencial respecto al plano ortogonal a <math>\vec{i}</math>, que viene dado por la siguiente expresión:<math>\ \left| \sigma ·\vec i -(\vec i·\sigma·\vec i)\vec i \right| </math> 

Con los datos hallados anteriormente obtenemos:

<math>|\begin{pmatrix}
sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}</math>. <math>\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}-\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}\begin{pmatrix}
sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}|=\frac{πx}{36}cos(\frac{π}{12}y)</math>

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>

<center><math>σ = \begin{pmatrix}σ1 & 0 & 0 \\
0 &σ2 & 0 \\
0 & 0 &σ3\end{pmatrix}</math> = <math>\begin{pmatrix}sin(\frac{π}{12}y) & 0 & 0 \\
0 &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}</math></center>

Utilizaremos el siguiente código para el cálculo de la tensión máxima de Von Mises así como la representación de la misma:

[[Archivo:Tensionvonmises16a.png|400px|miniaturadeimagen|derecha|Tensión Von Mises]]

{{matlab|codigo=
clear
clc
h=0.2;
x=-1:h:1;
y=0:h:12;
[Mx,My]=meshgrid(x,y); %Creamos el mallado

Ti=sin((pi/12).*My); % Tension normal en i
Tj=(1/3)*sin((pi/12).*My); % Tension normal en j
Tk=(1/3)*sin((pi/12).*My); % Tension normal en k

%Autovalores de la tensión de Von Mises
Mz = ones(size(y,2),size(x,2));
T = zeros(3);
for m=1:length(y)
for n=1:length(x)
%Valores para cada componente del mallado para la función de tensión de Von Mises
a=Ti(m,n);
b=Tj(m,n);
c=Tk(m,n);
T=[a 0 0; 0,b,0; 0,0,c];
%Obtención de los autovalores de la tensión de Von Mises
[P,D]=eig(T);
Autoval1=D(1,1);
Autoval2=D(2,2);
Autoval3=D(3,3);
%Cálculo de Von Mises para cada componente
VonMises=sqrt( ((Autoval1-Autoval2)^2+(Autoval2-Autoval3)^2+(Autoval3-Autoval1)^2) * 1/2 );
Mz(m,n)=VonMises;
end
end

%Representamos Von Mises en la placa bidimensional
figure
surf(Mx,My,Mz)
colorbar
axis equal
xlabel('Eje X')
ylabel('Eje Y')
title('Tensión de Von Mises')
view(2)

%maxima tensión
maxSIGMA=max(M)

fprintf('El valor máximo de la tensión de Von Mises en la placa es %f\n',maxSIGMA)
}}

'''El valor máximo de la tensión de Von Mises en la placa es 0.666667'''

==Campo de fuerzas <math>\vec F</math>==
El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal
<center><math>\vec{F}=\frac{∂^2\vec{u}}{∂t^2}-∇· σ</math></center>
donde <math>∇ · σ</math> es el campo vectorial que se obtiene al hacer la divergencia de los vectores cuyas componentes son las filas de la matriz <math>σ</math>.
Calcular la velocidad de propagación de las ondas <math>v</math> en términos de las constantes de Lamé, suponiendo que <math>\vec{F} = 0</math>. Si la onda fuera longitudinal, es decir, tomando <math>\vec{a} = x/3\vec{i}</math>, ¿cuál sería la velocidad de propagación? Comprobar que sobre un mismo medio las ondas transversales y longitudinales no viajan a la misma velocidad, tal y como se observa en la transmisión de ondas sísmicas.

Nuestro vector <math>\vec{u}</math> es <math>\vec{u}=\vec{a}·sin(pi*k(d·\vec{r0}(x, y)−vt))</math> siendo <math>\vec{a}=x/3 \vec{i} </math>, <math>\vec{d}=1/12 \vec{j}</math> y <math>k=1</math>.
Sustituyendo las componentes dadas quedaría <math>\vec{u}=\frac{x}{3}sin (\frac{\pi*y}{12}-vt)\vec{i}.</math>

Calculando <math>∇ · σ</math> queda <math>∇ · σ = \frac{x}{36}cos (\frac{\pi*y}{12})\vec{j}</math>

Derivando:

<math>\frac{∂\vec{u}}{∂t}= 2/5 \vec{i}·(-v)·cos (\vec{i}+\vec{r0}(x, y) − vt)</math>

<math>\frac{∂^2\vec{u}}{∂t^2}= x/3 \vec{i}·v^2·(-sin(\frac{\pi*y}{12}-vt))\vec{i}.</math>

Sustituyendo en la ecuación de la elasticidad lineal y despejando la velocidad:

<math>\vec{F}=\frac{∂^2\vec{u}}{∂t^2}-∇· σ=[x/3 \vec{i}·v^2·(-sin(\frac{\pi*y}{12}-vt))\vec{i}-\frac{x}{36}cos (\frac{\pi*y}{12})\vec{j}=0</math>

==Módulo del desplazamiento transversal==

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-14T22:12:10Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]
El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuerza determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana. Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:
[[Archivo:Mallado16a.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis equal
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas, que representa la variación de temperatura a lo largo de la placa. Usaremos el siguiente código:
[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN DEL CAMPO DE TEMPERATURAS''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|350px|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|400px|Figura 5. Ampliación Gradiente de Temperatura]]

<center> '''INTERPRETACIÓN DEL GRADIENTE DEL CAMPO DE TEMPERATURAS''' </center>

El gradiente apunta a los puntos de la gráfica a los cuales la gráfica tiene un mayor incremento de temperatura.

==Ley de Fourier==

De acuerdo a la Ley de Fourier la energía calorífica Q viaja de acuerdo a la fórmula
Q = −κ∇T,
donde κ es la constante de conductividad térmica de la placa que supondremos κ = 1.
[[Archivo:Ley_de_Fourier16a1.png|miniaturadeimagen|400px|Figura 5. Ley de Fourier]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
k=1; %Constante de conductividad térmica
dx=-(6.*(X-1))./(1+(X-1).^2);
dy=-(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Ley de Fourier");
hold off
}}

<center> '''INTERPRETACIÓN DE LA ENERGÍA CALORÍFICA''' </center>
Podemos apreciar la similitud con el gradiente. Según la Ley de Fourier el flujo de transferencia de calor es proporcional y de sentido contrario al gradiente de temperatura en esa dirección.

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación:
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (\pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Siendo <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math>

Por lo que:
<center><math>\vec{u}(x, y)=\frac{x}{3}sin (\frac{\pi*y}{12})\vec{i}.</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

[[Archivo:Campodedesplazamientos16a.png|miniaturadeimagen|derecha|425px|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
axis equal
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

<center> '''INTERPRETACIÓN DEL CAMPO DE VECTORES''' </center>

El campo de vectores queda representado en color rojo sobre la malla del sólido. Puesto que el campo de vectores se intensifica lateralmente siendo máximo en los cantos, podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

==Comparación de la placa antes y después del desplazamiento==
La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después. Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando surf(). A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando hold on y hold of, que se muestre con líneas el sólido deformado.
[[Archivo:Comparacion16a.png|derecha|miniaturadeimagen|400px|Figura 7. Sólido antes de la deformación y después.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,3,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia sera positiva, y si tiene "sumideros" sera negativa.

Calculamos la divergencia de:

<center><math>\vec{u}(x, y)=\frac{x}{3}sin (\frac{\pi*y}{12})\vec{i}.</math></center>

Entonces:

<center><math>\nabla ·\vec u = \frac{\partial u_1}{\partial x} + \frac{\partial u_2}{\partial y} = \frac{1}{3}sin (\frac{\pi*y}{12}) </math></center>

Utilizaremos el codigo que se muestra a continuación para obtener los valores máximos y mínimos de la divergencia.

[[Archivo:figura6 equivocacion.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]
[[Archivo:figura6 equivocacion2.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
%Dibujo de la divergencia
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))
}}

'''En la grafica se puede apreciar que la divergencia es de 0.333 y la mínima es tambien la nula, es decir, 0.'''

== Rotacional del sólido ==

En este siguiente apartado calcularemos el rotacional y a continuación lo representaremos.

<center><math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = -\frac{\pi*x}{36}*cos(\frac{pi*y}{12})\vec{k} </math>.</center>

[[Archivo:Rot16a.png|500px|miniaturadeimagen|Módulo del rotacional]]
{{matlab|codigo=
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=-((Mx.*pi)/36).*cos((pi.*My)/12)
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1,1,0,12]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y')

}}

<center> '''INTERPRETACIÓN DEL ROTACIONAL''' </center>
Como podemos observar los puntos que sufren un mayor rotacional son aquellos representados en color amarillo, estos tendrán una mayor capacidad de giro ya que el rotacional nos indica la capacidad que tienen los distintos puntos de nuestra placa para girar sobre otro punto determinado.

==Tensiones en las direcciones <math>\vec i </math>, <math>\vec j </math>, <math>\vec k </math> ==
Definamos <math>e(\vec{u}) = (∇\vec{u} + \triangledown \vec{u}^{t})/2</math>, la parte simétrica del tensor gradiente de <math>\vec{u}</math> conocido como tensor de deformaciones. En un medio elástico lineal, isótropo y homogéneo los desplazamientos
permiten escribir el tensor de tensiones <math>σ_{ij}</math> a través de la fórmula <math>σ = λ∇ · \vec{u} 1 + 2 μe</math>,
donde λ y μ son los conocidos como coeficientes de Lamé que dependen de las propiedades elásticas de cada material. A pesar de que los desplazamientos son planos (es decir <math>\vec{u}</math> no tiene componente en la dirección de <math>\vec{k}</math>) las tensiones no tienen por qué ser planas y puede haber tensiones en la dirección ortogonal al plano de la placa. Tomando <math>λ = μ = 1</math>. Asi que pasamos a dibujar las tensiones normales en la dirección que marca el eje <math>\vec{i}</math>, es decir <math>\vec{i}·σ·\vec{i}</math>, las tensiones normales en la dirección que marca el eje <math>\vec{j}</math>, es decir <math>\vec{j}·σ·\vec{j}</math> y las correspondientes al eje <math>\vec{k}</math>, es decir <math>\vec{k}·σ·\vec{k}</math>.

Primero para calcular e, debemos calcular el gradiente de <math>e(\vec{u})</math> y su transpuesto.
<center><math>\vec{u}(x, y)=\frac{x}{3}sin (\frac{\pi*y}{12})\vec{i}.</math></center>

<math> \nabla\vec u=
\begin{pmatrix}\frac {\partial u_1}{\partial x} & \frac{\partial u_1}{\partial y} & \frac{\partial u_1}{\partial z} \\
\frac{\partial u_2}{\partial x} & \frac{\partial u_2}{\partial y} & \frac{\partial u_2}{\partial z} \\
\frac{\partial u_3}{\partial x} & \frac{\partial u_3}{\partial y} & \frac{\partial u_3}{\partial z}\end{pmatrix} =
\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
0 & 0 & 0\\
0 & 0 & 0\end{pmatrix}
</math>

Hallamos su transpuesta.

<math>\nabla \vec u ^t=
\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & 0 & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) & 0 & 0 \\
0 & 0 & 0\end{pmatrix}
</math>

Encontramos <math>e(\vec{u})</math> aplicando la fórmula.

<math>e(\vec{u}) =
\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & \frac{πx}{72}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{72}cos(\frac{π}{12}y) & 0 & 0 \\
0 & 0 & 0\end{pmatrix}
</math>

Teniendo todos los datos, ya podemos calcular nuestro tensor de tensiones <math>σ_{ij}</math> a través de la fórmula <math>σ = λ∇ · \vec{u} 1 + 2 μe</math>.

<math>σ = λ\frac{1}{3}sin(\frac{π}{12}y)\begin{pmatrix}1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1\end{pmatrix}+2μ\begin{pmatrix}\frac{1}{3}sin(\frac{π}{12}y) & \frac{πx}{72}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{72}cos(\frac{π}{12}y) & 0 & 0 \\
0 & 0 & 0\end{pmatrix}</math>

<math>σ = \begin{pmatrix}\frac{1}{3}sin(\frac{π}{12})(2μ+λ) & \frac{πx}{36}cos(\frac{π}{12}y)(μ) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y)(μ) &\frac{1}{3}sin(\frac{π}{12}y)(λ) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)(λ)\end{pmatrix}</math>

Teniendo en cuenta que λ=μ=1, obtenemos:

<math>σ = \begin{pmatrix}sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}</math>

Por último se procede al cálculo de las tensiones normales a la dirección que marca cada vector de la base ortonormal orientada positivamente adoptada.
Dichas tensiones son las que se encuentran en los elementos de la diagonal de la matriz <math>\sigma_{ij}</math>:

=== Tensiones normales en dirección del eje <math>\vec i </math> ===

Aplicamos: <math>\vec i \cdot \sigma_{ij} \cdot \vec i = sin(\frac{π}{12}y)</math>

[[Archivo:Tension normal en i.png|400px|miniaturadeimagen|right|Figura 11. Tension Normal en i]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
%Generación de la retícula rectangular
[xx,yy]=meshgrid(x,y);
%tensiones normales en la dirección normal del eje i
tni=sin((pi.*yy)/12);
tnj=(1/3).*sin((pi.*yy)/12);
tnk=(1/3).*sin((pi.*yy)/12);
%Representación tensiones normales
figure
surf(xx,yy,tni)
shading flat
axis equal
colorbar
axis([-1.5,2,-1,15]);
title('Tensión normal en dirección i');
xlabel('Eje X');
ylabel('Eje Y');
view(2);
}}

=== Tensiones normales en dirección del eje <math>\vec j </math> ===

Aplicamos: <math>\vec j \cdot \sigma_{ij} \cdot \vec j = \frac{1}{3}sin(\frac{π}{12}y)</math>

[[Archivo:Tension normal en j.png|400px|miniaturadeimagen|right|Figura 12. Tension Normal en j]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
%Generación de la retícula rectangular
[xx,yy]=meshgrid(x,y);
%tensiones normales en la dirección normal del eje j
tni=sin((pi.*yy)/12);
tnj=(1/3).*sin((pi.*yy)/12);
tnk=(1/3).*sin((pi.*yy)/12);
surf(xx,yy,tnj)
shading flat
axis equal
colorbar
axis([-1.5,2,-1,15]);
title('Tensión normal en dirección j');
xlabel('Eje X');
ylabel('Eje Y');
view(2);
}}

=== Tensiones normales en dirección del eje <math>\vec k </math> ===

Aplicamos: <math>\vec k \cdot \sigma_{ij} \cdot \vec k = \frac{1}{3}sin(\frac{π}{12}y)</math>

[[Archivo:Tension normal en k1.png|400px|miniaturadeimagen|right|Figura 13. Tension Normal en k]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
%Generación de la retícula rectangular
[xx,yy]=meshgrid(x,y);
%tensiones normales en la dirección normal del eje k
tni=sin((pi.*yy)/12);
tnj=(1/3).*sin((pi.*yy)/12);
tnk=(1/3).*sin((pi.*yy)/12);
surf(xx,yy,tnk)
shading flat
axis equal
colorbar
axis([-1.5,2,-1,15]);
title('Tensión normal en dirección k');
xlabel('Eje X');
ylabel('Eje Y');
view(2);
}}

==Tensiones tangenciales respecto al plano ortogonal a <math>\vec{i}</math>==

Sea <math>\vec{T}</math> la tensión tangencial respecto al plano ortogonal a <math>\vec{i}</math>, que viene dado por la siguiente expresión:<math>\ \left| \sigma ·\vec i -(\vec i·\sigma·\vec i)\vec i \right| </math> 

Con los datos hallados anteriormente obtenemos:

<math>|\begin{pmatrix}
sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}</math>. <math>\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}-\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}\begin{pmatrix}
sin(\frac{π}{12}y) & \frac{πx}{36}cos(\frac{π}{12}y) & 0 \\
\frac{πx}{36}cos(\frac{π}{12}y) &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}\begin{pmatrix}1\\ 0\\ 0\end{pmatrix}|=\frac{πx}{36}cos(\frac{π}{12}y)</math>

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>

<center><math>σ = \begin{pmatrix}σ1 & 0 & 0 \\
0 &σ2 & 0 \\
0 & 0 &σ3\end{pmatrix}</math> = <math>\begin{pmatrix}sin(\frac{π}{12}y) & 0 & 0 \\
0 &\frac{1}{3}sin(\frac{π}{12}y) & 0 \\
0 & 0 &\frac{1}{3}sin(\frac{π}{12}y)\end{pmatrix}</math></center>

Utilizaremos el siguiente código para el cálculo de la tensión máxima de Von Mises así como la representación de la misma:

[[Archivo:Tensionvonmises16a.png|400px|miniaturadeimagen|derecha|Tensión Von Mises]]

{{matlab|codigo=
clear
clc
h=0.2;
x=-1:h:1;
y=0:h:12;
[Mx,My]=meshgrid(x,y); %Creamos el mallado

Ti=sin((pi/12).*My); % Tension normal en i
Tj=(1/3)*sin((pi/12).*My); % Tension normal en j
Tk=(1/3)*sin((pi/12).*My); % Tension normal en k

%Autovalores de la tensión de Von Mises
Mz = ones(size(y,2),size(x,2));
T = zeros(3);
for m=1:length(y)
for n=1:length(x)
%Valores para cada componente del mallado para la función de tensión de Von Mises
a=Ti(m,n);
b=Tj(m,n);
c=Tk(m,n);
T=[a 0 0; 0,b,0; 0,0,c];
%Obtención de los autovalores de la tensión de Von Mises
[P,D]=eig(T);
Autoval1=D(1,1);
Autoval2=D(2,2);
Autoval3=D(3,3);
%Cálculo de Von Mises para cada componente
VonMises=sqrt( ((Autoval1-Autoval2)^2+(Autoval2-Autoval3)^2+(Autoval3-Autoval1)^2) * 1/2 );
Mz(m,n)=VonMises;
end
end

%Representamos Von Mises en la placa bidimensional
figure
surf(Mx,My,Mz)
colorbar
axis equal
xlabel('Eje X')
ylabel('Eje Y')
title('Tensión de Von Mises')
view(2)

%maxima tensión
maxSIGMA=max(M)

fprintf('El valor máximo de la tensión de Von Mises en la placa es %f\n',maxSIGMA)
}}

'''El valor máximo de la tensión de Von Mises en la placa es 0.666667'''

==Campo de fuerzas <math>\vec F</math>==
El campo de fuerzas <math>\vec{F}</math> que actúa sobre la placa (y que son las causantes del desplazamiento observado) se aproxima usando la ecuación de la elasticidad lineal
<center><math>\vec{F}=\frac{∂^2\vec{u}}{∂t^2}-∇· σ</math></center>
donde <math>∇ · σ</math> es el campo vectorial que se obtiene al hacer la divergencia de los vectores cuyas componentes son las filas de la matriz <math>σ</math>.
Calcular la velocidad de propagación de las ondas <math>v</math> en términos de las constantes de Lamé, suponiendo que <math>\vec{F} = 0</math>. Si la onda fuera longitudinal, es decir, tomando <math>\vec{a} = x/3\vec{i}</math>, ¿cuál sería la velocidad de propagación? Comprobar que sobre un mismo medio las ondas transversales y longitudinales no viajan a la misma velocidad, tal y como se observa en la transmisión de ondas sísmicas.

Nuestro vector <math>\vec{u}</math> es <math>\vec{u}=\vec{a}·sin(pi*k(d·\vec{r0}(x, y)−vt))</math> siendo <math>\vec{a}=x/3 \vec{i} </math>, <math>\vec{d}=1/12 \vec{j}</math> y <math>k=1</math>.
Sustituyendo las componentes dadas quedaría <math>\vec{u}=\frac{x}{3}sin (\frac{\pi*y}{12}-vt)\vec{i}.</math>

Calculando <math>∇ · σ</math> queda <math>∇ · σ = \frac{x}{36}cos (\frac{\pi*y}{12})\vec{j}</math>

Derivando:

<math>\frac{∂\vec{u}}{∂t}= 2/5 \vec{i}·(-v)·cos (\vec{i}+\vec{r0}(x, y) − vt)</math>

<math>\frac{∂^2\vec{u}}{∂t^2}= x/3 \vec{i}·v^2·(-sin(\frac{\pi*y}{12}-vt))\vec{i}.</math>

Sustituyendo en la ecuación de la elasticidad lineal y despejando la velocidad:

<math>\vec{F}=\frac{∂^2\vec{u}}{∂t^2}-∇· σ=[x/3 \vec{i}·v^2·(-sin(\frac{\pi*y}{12}-vt))\vec{i}-\frac{x}{36}cos (\frac{\pi*y}{12})\vec{j}=0</math>

==Módulo del desplazamiento transversal==

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T22:54:25Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:
[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas, que representa la variación de temperatura a lo largo de la placa. Usaremos el siguiente código:
[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN DEL CAMPO DE TEMPERATURAS''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

<center> '''INTERPRETACIÓN DEL GRADIENTE DEL CAMPO DE TEMPERATURAS''' </center>

El gradiente apunta a los puntos de la gráfica a los cuales la gráfica tiene un mayor incremento de temperatura.

==Ley de Fourier==

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación:
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (\pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

<center> '''INTERPRETACIÓN DEL CAMPO DE VECTORES''' </center>

El campo de vectores queda representado en color rojo sobre la malla del sólido. Puesto que el campo de vectores se intensifica lateralmente siendo máximo en los cantos, podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

==Comparación de la placa antes y después del desplazamiento==

La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes
<math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después <math>\vec{r_{d}}(x, y)=\vec{r_{0}}(x, y)+\vec{u}(x, y).</math>.
Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando ''surf()''. A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando ''hold on'' y ''hold of'', que se muestre con líneas el sólido deformado.

[[Archivo:AntesyDespues.png|miniaturadeimagen|derecha|Figura 7. Sólido antes de la deformación, después y comparación.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

Calculamos la divergencia de <math>\vec u </math> :

<center><math>\vec u(x,y) = \frac{x}{3}\vec{i}sin(\pi(\frac{1}{12}\vec{j}·\vec{r_{0}}(x,y)))</math></center>

Siendo <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math>

Entonces:

<center> <math>\nabla ·\vec u = \frac{\partial u_1}{\partial x} + \frac{\partial u_2}{\partial y} = \frac{1}{3}sin(\frac{π}{12}y) </math></center>

Utilizaremos el código que se muestra a continuación para obtener los valores máximos y mínimos de la divergencia.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
%Dibujo de la divergencia
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))
}}

'''En la figura se puede apreciar que la divergencia máxima es de 0.333 y la mínima es también la nula, es decir, 0.'''

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \frac{xy}{36}*cos(\frac{pi*y}{12})\vec{k} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T22:53:31Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:
[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas, que representa la variación de temperatura a lo largo de la placa. Usaremos el siguiente código:
[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN DEL CAMPO DE TEMPERATURAS''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

<center> '''INTERPRETACIÓN DEL GRADIENTE DEL CAMPO DE TEMPERATURAS''' </center>

El gradiente apunta a los puntos de la gráfica a los cuales la gráfica tiene un mayor incremento de temperatura.

==Ley de Fourier==

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación:
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (\pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

<center> '''INTERPRETACIÓN DEL CAMPO DE VECTORES'' </center>

El campo de vectores queda representado en color rojo sobre la malla del sólido. Puesto que el campo de vectores se intensifica lateralmente siendo máximo en los cantos, podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

==Comparación de la placa antes y después del desplazamiento==

La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes
<math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después <math>\vec{r_{d}}(x, y)=\vec{r_{0}}(x, y)+\vec{u}(x, y).</math>.
Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando ''surf()''. A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando ''hold on'' y ''hold of'', que se muestre con líneas el sólido deformado.

[[Archivo:AntesyDespues.png|miniaturadeimagen|derecha|Figura 7. Sólido antes de la deformación, después y comparación.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

Calculamos la divergencia de <math>\vec u </math> :

<center><math>\vec u(x,y) = \frac{x}{3}\vec{i}sin(\pi(\frac{1}{12}\vec{j}·\vec{r_{0}}(x,y)))</math></center>

Siendo <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math>

Entonces:

<center> <math>\nabla ·\vec u = \frac{\partial u_1}{\partial x} + \frac{\partial u_2}{\partial y} = \frac{1}{3}sin(\frac{π}{12}y) </math></center>

Utilizaremos el código que se muestra a continuación para obtener los valores máximos y mínimos de la divergencia.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
%Dibujo de la divergencia
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))
}}

'''En la figura se puede apreciar que la divergencia máxima es de 0.333 y la mínima es también la nula, es decir, 0.'''

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \frac{xy}{36}*cos(\frac{pi*y}{12})\vec{k} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T22:30:14Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:
[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas, que representa la variación de temperatura a lo largo de la placa. Usaremos el siguiente código:
[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN DEL CAMPO DE TEMPERATURAS''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(x,y); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

<center> '''INTERPRETACIÓN DEL GRADIENTE DEL CAMPO DE TEMPERATURAS''' </center>

El gradiente apunta a los puntos de la gráfica a los cuales la gráfica tiene un mayor incremento de temperatura.

==Ley de Fourier==

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación:
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (\pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

<center> '''INTERPRETACIÓN DEL CAMPO DE VECTORES'' </center>

==Comparación de la placa antes y después del desplazamiento==

La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes
<math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después <math>\vec{r_{d}}(x, y)=\vec{r_{0}}(x, y)+\vec{u}(x, y).</math>.
Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando ''surf()''. A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando ''hold on'' y ''hold of'', que se muestre con líneas el sólido deformado.

[[Archivo:AntesyDespues.png|miniaturadeimagen|derecha|Figura 7. Sólido antes de la deformación, después y comparación.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

Calculamos la divergencia de <math>\vec u </math> :

<center><math>\vec u(x,y) = \frac{x}{3}\vec{i}sin(\pi(\frac{1}{12}\vec{j}·\vec{r_{0}}(x,y)))</math></center>

Siendo <math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math>

Entonces:

<center> <math>\nabla ·\vec u = \frac{\partial u_1}{\partial x} + \frac{\partial u_2}{\partial y} = \frac{1}{3}sin(\frac{π}{12}y) </math></center>

Utilizaremos el código que se muestra a continuación para obtener los valores máximos y mínimos de la divergencia.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=
h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
%Dibujo de la divergencia
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))
}}

'''En la figura se puede apreciar que la divergencia máxima es de 0.333 y la mínima es también la nula, es decir, 0.'''

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \frac{xy}{36}*cos(\frac{pi*y}{12})\vec{k} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T10:12:54Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes
<math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después <math>\vec{r_{d}}(x, y)=\vec{r_{0}}(x, y)+\vec{u}(x, y).</math>.
Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando ''surf()''. A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando ''hold on'' y ''hold of'', que se muestre con líneas el sólido deformado.

[[Archivo:AntesyDespues.png|miniaturadeimagen|derecha|Figura 7. Sólido antes de la deformación, después y comparación.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T10:11:22Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO

La placa sufre una deformación provocada por el campo de vectores. Estudiamos el sólido antes y después de su deformación para t=0, conociendo el vector de posición de los puntos de la placa antes
<math>\vec{r_{0}}(x, y)= x \vec{i} + y \vec{j} </math> y la posición de cada punto (x,y) después <math>\vec{r_{d}}(x, y)=\vec{r_{0}}(x, y)+\vec{u}(x, y).</math>.
Para que resulte más sencilla su interpretación, se visualizará la gráfica antes, después y la comparación con ayuda del comando subplot.

Comenzamos representando la placa antes de la deformación como se ha hecho anteriormente, definimos los valores que toma el rectángulo y lo visualizamos con el comando ''surf()''. A continuación, definimos los puntos después del desplazamiento y los representamos de la misma manera. Para la comparación, se crea un gráfico que muestre mediante líneas el sólido sin deformaciones y sobre este, con el comando ''hold on'' y ''hold of'', que se muestre con líneas el sólido deformado.

[[Archivo:AntesyDespues.png|miniaturadeimagen|derecha|Figura x. Sólido antes de la deformación, después y comparación.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T09:46:29Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 6. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO
[[Archivo:AntesyDespues.png|sinmarco|derecha|Figura x. ]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T09:46:14Z

Lara.gutierrez: /* Gradiente de la temperatura */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Figura 4.Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Figura 5. Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 7. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO
[[Archivo:AntesyDespues.png|sinmarco|derecha|Figura x. ]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T09:36:12Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|miniaturadeimagen|derecha|Figura 7. Campo de vectores en t=0.]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y)); % Componentes en la dirección i
uy=(0.*Y); % Componentes en la dirección j
figure
mesh(X,Y,X*0) % Creación del mallado
hold on
quiver(X,Y,ux,uy,"r") % Campo de vectores, "r" define el color en la grafica
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO
[[Archivo:AntesyDespues.png|sinmarco|derecha|Figura x. ]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T09:28:27Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura del sólido.

[[Archivo:Desplazamiento2.png|sinmarco|derecha|Figura x. Campo de vectores en t=0]]
{{matlab|codigo=
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y));
uy=(0.*Y);
figure
mesh(X,Y,X*0)
hold on
quiver(X,Y,ux,uy,"r")
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO
[[Archivo:AntesyDespues.png|sinmarco|derecha|Figura x. ]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T09:27:54Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

Podemos observar como el campo es mas intenso en los laterales de la placa, por lo que podemos esperar que la deformación provoque un bombeo/ curvatura en la placa.

[[Archivo:Desplazamiento2.png|sinmarco|derecha|Figura x. Campo de vectores en t=0]]
{{matlab|codigo=
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y));
uy=(0.*Y);
figure
mesh(X,Y,X*0)
hold on
quiver(X,Y,ux,uy,"r")
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO
[[Archivo:AntesyDespues.png|sinmarco|derecha|Figura x. ]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-10T09:20:58Z

Lara.gutierrez: /* Campo de vectores */

{{ TrabajoED | Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A) | [[:Categoría:Teoría de Campos|Teoría de Campos]]|[[:Categoría:TC23/24|2023-24]] | Lara Gutiérrez Kreutzer Miguel Moreno Martín Luis Anthony Vera Guapi Emilio Villegas Maroto}}

[[Categoría:Teoría de Campos]]
[[Categoría:TC23/24]]

El presente trabajo tiene por objeto la visualización y representación de los campos escalares y vectoriales sobre un sólido que experimenta una deformación. Se ha considerado como objeto de estudio un sólido rectangular (en 2D) cuya deformación viene dada por la temperatura y los desplazamientos producidos por la acción de una fuera determinada.

Para su realización se empleará el software de programación y cálculo numérico Matlab.

==Representación de la placa==
En primer lugar, se representa la placa dibujando los puntos interiores del sólido mediante un mallado. Este está definido en la región <math>(x, y) ∈ [-1, 1]×[0, 12]</math> y como paso de muestreo se empleará h=2/10 para ambas variables.

Para su realización, se ha comenzado definiendo los vectores x e y con los valores que toma el rectángulo. Dichos vectores se han metido en dos matrices, X e Y, empleando el comando ''meshgrid()'' y con el comando ''mesh()'' se crea el mallado buscado. Este comando requiere tres matrices, por lo que en la ultima entrada multiplicamos cualquiera de las obtenidas por cero, puesto que se trata de una placa plana.
Por último, con el comando ''axis()'' se definen los valores que tomarán los ejes de la gráfica <math>(x, y) ∈ [-2, 2]×[0, 13]</math> y nombramos tanto la gráfica como los ejes.

A continuación, se muestra el código empleado para la obtención de la placa y la imagen resultante:

[[Archivo:Apartado1GraficoMalla.png|miniaturadeimagen|derecha|Figura 1. Representación del mallado]]

{{matlab|codigo=

x=-1:0.2:1; % Vector x con valores entre -1 y 1 con paso de muestreo h=2/10
y=0:0.2:12; % Vector y con valores entre 0 y 12 con paso de muestreo h=2/10
[X,Y]=meshgrid(x,y); % Creación del mallado con los vectores x e y
mesh(X,Y,0*X); % Dibujo de la malla pedida
axis([-2,2,0,13]) % Con el comando axis se definen los valores mínimos y máximos de los ejes de la gráfica
title("Mallado de la placa rectangular plana")
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
view(2) % Visualiamos el gráfico en dos dimensiones
}}

==Temperatura de la placa==

La temperatura del sólido viene dada por la función: <math>T(x, y) = 3log(1 +(x-1)^2)+log(1+(y-8)^2)</math>

Primero representaremos las distintas curvas de nivel del campo de temperaturas mediante el siguiente código:

[[Archivo:Curvas_nivel_temp1.png|miniaturadeimagen|Figura 2. curvas de nivel del campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
x=-1:h:1;
y=0:h:12;
[X,Y]=meshgrid(x,y)
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2);; %Función que representa la temperatura
contour(x,y,T,20); % Se dibujan las curvas de nivel
axis equal;
axis([-1,1,0,12]);
view(2); %Vista en planta
title("Curvas de nivel del campo de temperaturas") %Nombre de la figura
xlabel("Eje X") % Título del eje X
ylabel("Eje Y") % Título del eje Y
colorbar
}}

A continuación, mostraremos el campo de temperaturas que representa la variación de temperatura a lo largo de la placa, usando el siguiente código:

[[Archivo:Campo_temp.png|miniaturadeimagen|Figura 3. Campo de temperaturas ]]

{{matlab|codigo=
h=2/10; %Paso de muestreo
r=-1:h:1; % Discretización del radio
t=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función que representa la temperatura
surf(X,Y,T); %Se dibuja la placa
shading interp %Se realiza un degradado mediante interpolación con los colores de relleno
axis equal
axis([-1,1,0,12]);
colorbar
view(2)
title("Campo de temperaturas") %Nombre de la figura
Tmax=max(max(T)); %Se calcula la temperatura máxima alcanzada
fprintf('La temperatura máxima alcanzada en la placa es de: %1.4f ºC\n' , Tmax)
}}

'''Como resultado obtenemos que la temperatura máxima alcanzada en la placa es de: 9.0027 ºC.'''

<center> '''INTERPRETACIÓN FIGURA 3''' </center>
En la imagen podemos apreciar dos gamas de colores distintos, una primera de colores fríos (azul) que corresponden a unas temperaturas más bajas, mientras que la otra se trata de una gama de colores más cálidos (amarillo) que corresponden a temperaturas mayores.

=== Gradiente de la temperatura ===

En segundo lugar, calcularemos el gradiente de la temperatura, que es un vector cuya primera componente es la derivada del campo escalar de la temperatura respecto de <math>x</math>, multiplicada por el vector <math>\vec{i}</math> y como segunda componente la derivada del campo escalar respecto de <math>y</math>, multiplicada por el vector <math>\vec{j}</math>.

<center><math>∇T = \frac{\partial T}{\partial x}\vec{i} + \frac{\partial T}{\partial y}\vec{j} = \frac{6(x-1)}{1+(x-1)^2)}\vec{i} + \frac{2(y-8)}{1+(y-8)^2}\vec{j} </math></center>

Una vez calculado el gradiente, crearemos las variables <math>dx</math> y <math>dy</math> en función de las matrices <math>X</math> e <math>Y</math>. Por último, utilizaremos el comando <math>quiver ()</math> para representar el gradiente de la temperatura.

Al tener que comprobar que las curvas de nivel del campo de temperatura y el gradiente son perprendiculares, nos ayudaremos del comando <math>hold on</math> para poder representar las curvas de nivel y el gradiente en el mismo gráfico.

[[Archivo:Grad90.png|miniaturadeimagen|Gradiente de Temperatura]]

{{matlab|codigo=

h=2/10; %Paso de muestreo
x=-1:h:1; %Discretización del radio
y=0:h:12; %Discretización del ángulo
[X,Y]=meshgrid(r,t); %Generación de la retícula rectangular
T=3*log(1 +(X-1).^2)+log(1+(Y-8).^2); %Función de temperatura
dx=(6.*(X-1))./(1+(X-1).^2);
dy=(2.*(Y-8))./(1+(Y-8).^2);
axis equal;
hold on
quiver(x,y,dx,dy); %Se dibuja el gradiente
contour(x,y,T,20); %Se dibujan las curvas de nivel de la temperatura
axis([-1,1,0,12]);
title("Gradiente de temperatura");
hold off
}}

Como no se puede apreciar bien el gradiente en la imagen general, hemos realizado la siguiente ampliación donde se pude observar la ortogonalidad del gradiente.
[[Archivo:Grad90_ampliación.png|centre|Ampliación Gradiente de Temperatura]]

==Campo de vectores==

El campo de vectores viene definido por
<math>\vec{u}(x, y, t)=\vec{a}sin(k\pi(\vec{d}·\vec{r_{0}}(x,y)-vt)).</math> La representación de dicho campo para t=0 se hará tomando como valores para la amplitud, <math>\vec{a}= x/3 \vec{i}</math> ; el número de onda, k=1 ; y el vector unitario de propagación, <math>\vec{d}= 1/12 \vec{j}</math>.
Por lo que el campo de vectores vendrá dado por la ecuación
<center><math>\vec{u}(x, y)=x/3 \vec{i} sin (pi( 1/12 \vec{j}·\vec{r_{0}}(x,y))).</math></center>

Primero creamos las matrices X e Y de los puntos del mallado de la placa. Definimos las componentes en la dirección de <math>\vec{i}</math> y <math>\vec{j}</math> del campo de desplazamiento y con el comando ''mesh()'' dibujamos el mallado sobre el que vamos a poder ver el campo de vectores creados con ''quiver ()''.
Los comandos ''hold on'' y ''hold off'' permiten ver los vectores sobre el sólido sin que este último desaparezca.

[[Archivo:Desplazamiento2.png|sinmarco|derecha|Figura x. Campo de vectores en t=0]]
{{matlab|codigo=
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y)
ux=(X.*(1/3).*sin((pi/12).*Y));
uy=(0.*Y);
figure
mesh(X,Y,X*0)
hold on
quiver(X,Y,ux,uy,"r")
title("Campo de desplazamientos")
xlabel("Eje X")
ylabel("Eje Y")
view(2)
hold off
}}

==Comparación de la placa antes y después del desplazamiento==

INTRODUCCIÓN Y DESCRIPCIÓN DEL CÓDIGO
[[Archivo:AntesyDespues.png|sinmarco|derecha|Figura x. ]]

{{matlab|codigo=
clear
close all
x=-1:0.2:1;
y=0:0.2:12;
[X,Y]=meshgrid(x,y);
% Definimos la posición final
rx=(X.*(1/3).*sin((pi/12).*Y))+X;
ry=(0.*Y)+Y;
% Antes de desplazamiento
subplot(1,2,1)
surf(X,Y,0*X)
view(2)
title("Antes del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
% Después del desplazamiento
subplot(1,2,2)
surf(rx,ry,rx*0)
view(2)
title("Después del desplazamiento")
xlabel("Eje X")
ylabel("Eje Y")
%Comparación
subplot(1,3,3)
plot3(X,Y,0*Y)
hold on
plot3(X+rx,Y+ry,0*Y)
hold off
view(2)
title("Comparación")
xlabel("Eje X")
ylabel("Eje Y")
}}

==Divergencia==
La divergencia mide la diferencia entre el flujo saliente y el flujo entrante de un campo vectorial sobre la superficie que rodea a un volumen de control, por tanto, si el campo tiene "fuentes" la divergencia será positiva, y si tiene "sumideros", la divergencia será negativa.

[[Archivo: Diverge.png|miniaturadeimagen|Divergencia 2D]]
[[Archivo:Diverge2.png|miniaturadeimagen|Divergencia 3D]]

{{matlab|codigo=

h=2/10;
x=-1:h:1;
y=0:h:12;
[xx,yy]=meshgrid(x,y);
divu=(1/3).*sin((pi.*yy)/12);
%Representación
surf(xx,yy,divu)
shading interp
colorbar
title('Divergencia')
xlabel('x')
ylabel('y')
zlabel('z')
figure
pcolor(xx,yy,divu)
shading interp
hold on
contour(xx,yy,divu,'k')
title('Divergencia')
xlabel('x')
ylabel('y')
colorbar
axis([-1,1,0,12])
view(3)
hold off
maximo=max(max(divu))
minimo=min(min(divu))

}}

== Rotacional del sólido ==
Calcular <math>|∇ × \vec{u}|</math> en todos los puntos del sólido y dibujarlo. ¿Qué puntos sufren un mayor rotacional?

=== Cálculo del rotacional ===
<math>∇ × \vec{u}= \begin{vmatrix}\vec{i} & \vec{j}& \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y}& \frac{\partial }{\partial z}\\ u_{1}& u_{2}& u_{3} \end{vmatrix} = \begin{vmatrix} \vec{i} & \vec{j} & \vec{k}\\ \frac{\partial }{\partial x} & \frac{\partial }{\partial y} &\frac{\partial }{\partial z} \\ \frac{x}{3}\sin(\frac{pi*y}{12}) & 0 & 0\end{vmatrix} = \vec{\frac{xy}{36}*cos(\frac{pi*y}{12})} </math>.

=== Representación del módulo del rotacional ===
[[Archivo:Ejercicio27.gif|500px|miniatura de imagen|Módulo del rotacional (campo escalar)]]
{{matlab|codigo=
%Limpieza de programas anteriores
clc
clear
close all

%Definición de regiones
h=2/10;
x=[-1:h:1];
y=[0:h:12];
%Matriz de x e y
[Mx,My]=meshgrid(x,y);
%Cálculo del módulo del rotacional
rot=((Mx.*My)/36).*cos((pi*My)/12);
%Representación gráfica
surf(Mx,My,rot)
shading flat
axis equal
colorbar
view(2);
axis([-1.5,1.5,-0.5,12.5]);
title('Módulo del rotacional');
xlabel('Eje X');
ylabel('Eje Y');

}}

==Tensión de Von Mises==

La tensión de Von Mises es una magnitud física proporcional a la energía de distorsión. Debe su nombre a Richard Edler von Mises quien propuso que un material dúctil sufría fallo elástico cuando la energía de distorsión elástica rebasaba cierto valor. En resumen, se trata de una magnitud escalar que se suele usar como indicador para saber cuando un material inicia un comportamiento plástico y no elástico puro.

[[Archivo:Von_misesp.jpg|100px|derecha|Richard Edler von Mises]]

Esta viene determinada por la siguiente fórmula:
<center> <math> \sigma_V =\sqrt{\frac{(\sigma_1-\sigma_2)^2+(\sigma_2-\sigma_3)^2+(\sigma_3-\sigma_1)^2}{2}}</math> 
σ1,σ2,σ3 son los autovalores del tensor de tensiones σ(ρ,θ).</center>
Para este supuesto, la tensión de Von Mises representará la máxima tensión que puede soportar la placa antes de iniciar un comportamiento plástico.

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T16:24:37Z

Lara.gutierrez: /* Campo de vectores */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T11:21:24Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T11:20:45Z

Lara.gutierrez: /* Campo de vectores */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T11:19:50Z

Lara.gutierrez: /* Campo de vectores */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T10:47:58Z

Lara.gutierrez: /* Campo de vectores */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T10:38:42Z

Lara.gutierrez:

Archivo:Desplazamiento2.png

2023-12-07T10:31:31Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T10:13:51Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T10:13:30Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T10:12:34Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-07T10:12:05Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

Archivo:AntesyDespues.png

2023-12-07T10:09:57Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-06T13:15:28Z

Lara.gutierrez: /* Comparación de la placa antes y después del desplazamiento */

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-06T13:12:08Z

Lara.gutierrez:

Archivo:Desplaamiento5.png

2023-12-06T13:10:14Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-06T13:07:38Z

Lara.gutierrez:

Archivo:AntesyDesp despl.png

2023-12-06T13:05:06Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-04T19:48:35Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-04T15:15:59Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-04T13:24:36Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-03T22:28:10Z

Lara.gutierrez:

Archivo:TemperaturaA22.png

2023-12-03T22:24:59Z

Lara.gutierrez:

Visualización de campos escalares y vectoriales en elasticidad (Grupo 16-A)

2023-12-03T22:24:31Z

Lara.gutierrez: