MateWiki - Contribuciones del usuario [es]

Flujo estacionario en medio poroso (RoYa)

2025-11-16T21:45:46Z

YanWang: /* Póster del Trabajo */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

{|style="margin: 0 auto;"
| [[Archivo:Poster_RoYa2.png|900px|thumb|right|Trabajo de Métodos Numéricos en Ecuaciones Diferenciales en Derivadas Parciales sobre el flujo estacionario en medio poroso.]]
|}

=Códigos de MatLab=

A continuación, se presentan los códigos empleados para la realización del póster.

Para empezar se muestra los código utilizados para generar los documentos necesarios para las diferentes mallas. Para la malla del cuadrado de 4 triángulos se emplea el siguiente código:

{{matlab|codigo=
% Lado del cuadrado inicial.
a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados.

% Nombres de los documentos creados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'}; % Se emplea para los títulos de las gráficas

% Datos fijos necesarios dentro del bucle.
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

% Bucle para crear las diferente mallas para cada paso.

for p = 1:3
h = H(p);
x = a:h:b; % División del lado en trozos de tamaño h
xm = a+(h/2):h:b; % Coordenada x de los centroides de los cuadrados en los que se divide el cuadrado inicial.
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1); % Vector con las coordenadas x de los nodos que forman los cuadrados y su centroide .
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

% Esta parte crea el documento con la numeración de los nodos y sus coordenada x e y.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l % La numeración de los nodos se basa en el número de nodos que ya se han contado dependiendo del nodo en el que me hallo.
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

% Este trozo crea el documento con la numeración de los elementos y los nodos que forman cada elemento.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4 % El primer elemento es el triángulo de la izquierda, el segundo el de abajo, el tercero el de la derecha y el cuarto el de arriba. La numeración
if k == 1 % de los elementos se basa en el número de cuadrados contados dependiendo del nodo del centroide del cuadrado en el que me hallo.
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

% Esta parte crea el documento que contiene la numeración de los nodos que forman parte de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2 % Los nodos que forman parte de la frontera Dirichlet son aquellos cuya coordenada x es igual a 0 o 1.
for j = 1:n % Luego, el número de nodos ya contados es proporcional.
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

% Este trozo de código crea el documento que relaciona los nodos de las mallas menos finas con la malla más fija, es decir, las mallas con paso h igual a 0.1 y 0.05 con la malla con paso h igual a 0.025.

if p == 1 % Malla con paso h igual a 0.1 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1 % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 1ª y 3ª fila.
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones.
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 2ª y 4ª fila más los de la 1ª fila.
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2 % Malla con paso h igual a 0.05 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 2 posiciones.
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

% Este parte representa gráficamente los diferentes mallados para cada paso.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Este trozo dibuja gráficamente los nodos de las mallas menos finas y los de la malla más fina. Esta parte sirve para comprobar que la relación entre los nodos está bien escrita. O sea, si el nodo i de la malla menos fina se corresponde al nodo j de la malla más fina.

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end
}}

El siguiente código realiza la malla del cuadrado de 2 triángulos. Es el mismo código que el anterior pero modificado ligeramente. La idea para la numeración es la misma pero modifica a esta forma de mallado.

{{matlab|codigo=

a = 0;
b = 1;

H = [0.1 0.05 0.025];

V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt','Relacion_malla3malla3_tipo1.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
n = length(x);

% Crea el documento para los nodos.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for j = 1:n
for i = 1:n
nodo = [(j-1)*n + i, x(i), x(j)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
fclose(Verticesdoc);

% Crea el documento para los elementos.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:n-1
for j = 1:n-1
triang = [(2*(j-1)+1)+(n-1)*(i-1), n*(i-1)+j, n*(i-1)+j+1, n*i+j];
fprintf(Elementosdoc,formatSpec,triang);
triang = [(2*(j-1)+2)+(n-1)*(i-1), n*i+j+1, n*i+j, n*(i-1)+j+1];
fprintf(Elementosdoc,formatSpec,triang);
end
end
fclose(Elementosdoc);

% Crea el documento para los nodos de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,1+n*(j-1));
else
fprintf(Dirichletdoc,formatSpec,n+n*(j-1));
end
end

end
fclose(Dirichletdoc);

% Crea el documento para la relación entre las mallas de 2 triángulos con la malla de 4 triángulos con paso h igual a 0.025.

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
for j = 1:n
c = 8*(i-1)+1;
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 4*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
else
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 2*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+j];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
end

% Representa las diferentes mallas.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Representa los nodos de la relación para la comprobación.

for p = 1:3
Vertices = load(V{p});
Elememtos = load(E{p});
Vert = load('Vertices_malla3_tipo1.txt');
Elem = load('Elementos_malla3_tipo1.txt');
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,2);
coord2 = zeros(size(Vert,1),2);
nodos2 = zeros(size(Elem,1),3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+4)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,1),1),coord(Rel(:,1),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,2),1),coord2(Rel(:,2),2),'r.','MarkerSize',20);
hold off
end
}}

Lo siguientes códigos realizan el MEF. Primero se muestra con las mallas de 4 triángulos.

{{matlab|codigo=

% Documentos donde se encuentra la información de las mallas.

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

% Lado del cuadrado inicial.

a = 0;
b = 1;

% Condiciones de tipo Dirichlet.

p0 = 0.5;
p1 = 0;

% Datos del problema.

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

% Matrices empleadas para calcular la matriz de rigidez por ensamblado.

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

% Variables de la tabla final sobre la convergencia.

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

% Resolución del problema para las mallas de cada paso.

for p =1:3

% Lectura de los documentos y creación de variables con los datos de estos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Matrices del problema en forma matricial.

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación valores a la solución de los nodos de la frontera Dirichlet.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir)); % Nodos cuya solución hay que calcular

% Ensamblado de la matriz de rigidez y el vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3 % Aproximación de la integral de f y K sobre cada elemento como un promedio.
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir % Ajuste del vector de cargas.
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind); % Resolución del problema matricial.

Sol(1:length(u),p) = u;

% Representación de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');

end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden en las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})

}}

Ahora, se muestra el mismo código pero ajustado con la parte de convergencia ajustada para comparar con la malla de 4 triángulos más fina.

{{matlab|codigo=
V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt', 'Relacion_malla3malla3_tipo1.txt'};

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
Exacta = zeros(length(a:H(end):b),1);
coord5 = zeros(length(a:H(end):b),1);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:4

% Lectura de documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

if p ==3 % Almacenamos las coordenadas de la malla de 2 triángulos más fina para uso posterior.
coord5 = coord;
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de variables con valores conocidos

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

if p == 4 % Almacenamos la solución de la malla de 4 triángulos en una variable diferente.
Exacta(1:length(u)) = u;
else
Sol(1:length(u),p) = u;
end

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');
end

% Representación gráfica de la diferencia entre la solución de la malla de 2 triángulos más fina con la solución de la malla de 4 triángulos más fina.

Rel = load(R{3});
Elementos= load(E{3});
figure(p+1)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(Elementos(:,2:end),coord5(:,1),coord5(:,2),abs(Sol(:,3)-Exacta(Rel(:,2))));view(0,90);
colorbar;
title('|u-u_h|');

% Creación de variables necesarias para la convergencia.

Vert = load(V{4});
Elem = load(E{4});
M4 = size(Vert,1);
Nel4 = size(Elem,1);
coord4 = zeros(M4,2);
nodos4 = zeros(Nel4,3);
for i = 1:M4
for j = 1:2
coord4(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel4
for j = 1:3
nodos4(i,j) = Elem(i,j+1);
end
end

% Cálculo de la convergencia.

for p = 1:3
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas de 2 triángulos con la solución de la malla de 4 triángulos más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk4 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk4(j,k) = coord4(Rel(nodosK(k+1),2),j)-coord4(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk4 = det(Bk4);
invBk4 = inv(Bk4);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk4 = [Exacta(Rel(nodosK(2),2))-Exacta(Rel(nodosK(1),2)); Exacta(Rel(nodosK(3),2))-Exacta(Rel(nodosK(1),2))];
for j = 1:3
sumL = sumL + (Exacta(Rel(nodosK(j),2)) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk4'*uk4 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

for i = 1:2
ordenL(i) = log(normL(i)/normL(i+1))/log(2);
ordenH(i) = log(normH(i)/normH(i+1))/log(2);
end

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

Por último, se muestra de nuevo el código pero modificado para el nuevo dominio.

{{matlab|codigo=

V = {'Vertices_malla1_tipo3.txt', 'Vertices_malla2_tipo3.txt', 'Vertices_malla3_tipo3.txt'};
E = {'Elementos_malla1_tipo3.txt', 'Elementos_malla2_tipo3.txt', 'Elementos_malla3_tipo3.txt'};
D = {'Dirichlet_malla1_tipo3.txt', 'Dirichlet_malla2_tipo3.txt', 'Dirichlet_malla3_tipo3.txt'};
R = {'Relacion_malla1malla3_tipo3.txt', 'Relacion_malla2malla3_tipo3.txt'};

% Lectura de una de las mallas para el cálculo del centroide del dominio.

Vertices = load(V{3});
Elementos = load(E{3});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo del centroide del dominio por cambio de variable al elemento de referencia.

area2 = 0;
xcmintcv = 0;
ycmintcv = 0;
for i = 1:Nel
jac = zeros(2,2);
triang = [nodos(i,1), nodos(i,2), nodos(i,3)];
for j = 1:2
for k = 1:2
jac(j,k) = coord(triang(k+1),j)-coord(triang(1),j);
end
end
detjac = abs((jac(1,1)*jac(2,2))-(jac(1,2)*jac(2,1)));
areael = detjac*(1/2);
area2 = area2 + areael;
intx = @(a,b) jac(1,1)*a + jac(1,2)*b + coord(triang(1),1);
inty = @(a,b) jac(2,1)*a + jac(2,2)*b + coord(triang(1),2);
xcmintcv = xcmintcv + detjac*integral2(intx,0,1,0,@(z) -z+1);
ycmintcv = ycmintcv + detjac*integral2(inty,0,1,0,@(z) -z+1);
end
xcmcv = xcmintcv/area2;
ycmcv = ycmintcv/area2;

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-xcmcv).^2 + (y-ycmcv).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:3

% Lectura de los documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de valores conocidos.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas.

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

Sol(1:length(u),p) = u;

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title(strcat('u_h con h =',num2str(H(p))));
end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la solución de la malla más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Flujo estacionario en medio poroso (RoYa)

2025-11-16T21:45:16Z

YanWang: /* Póster del Trabajo */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

{|style="margin: 0 auto;"
| [[Archivo:Poster_RoYa2.jpg|900px|thumb|right|Trabajo de Métodos Numéricos en Ecuaciones Diferenciales en Derivadas Parciales sobre el flujo estacionario en medio poroso.]]
|}

=Códigos de MatLab=

A continuación, se presentan los códigos empleados para la realización del póster.

Para empezar se muestra los código utilizados para generar los documentos necesarios para las diferentes mallas. Para la malla del cuadrado de 4 triángulos se emplea el siguiente código:

{{matlab|codigo=
% Lado del cuadrado inicial.
a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados.

% Nombres de los documentos creados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'}; % Se emplea para los títulos de las gráficas

% Datos fijos necesarios dentro del bucle.
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

% Bucle para crear las diferente mallas para cada paso.

for p = 1:3
h = H(p);
x = a:h:b; % División del lado en trozos de tamaño h
xm = a+(h/2):h:b; % Coordenada x de los centroides de los cuadrados en los que se divide el cuadrado inicial.
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1); % Vector con las coordenadas x de los nodos que forman los cuadrados y su centroide .
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

% Esta parte crea el documento con la numeración de los nodos y sus coordenada x e y.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l % La numeración de los nodos se basa en el número de nodos que ya se han contado dependiendo del nodo en el que me hallo.
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

% Este trozo crea el documento con la numeración de los elementos y los nodos que forman cada elemento.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4 % El primer elemento es el triángulo de la izquierda, el segundo el de abajo, el tercero el de la derecha y el cuarto el de arriba. La numeración
if k == 1 % de los elementos se basa en el número de cuadrados contados dependiendo del nodo del centroide del cuadrado en el que me hallo.
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

% Esta parte crea el documento que contiene la numeración de los nodos que forman parte de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2 % Los nodos que forman parte de la frontera Dirichlet son aquellos cuya coordenada x es igual a 0 o 1.
for j = 1:n % Luego, el número de nodos ya contados es proporcional.
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

% Este trozo de código crea el documento que relaciona los nodos de las mallas menos finas con la malla más fija, es decir, las mallas con paso h igual a 0.1 y 0.05 con la malla con paso h igual a 0.025.

if p == 1 % Malla con paso h igual a 0.1 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1 % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 1ª y 3ª fila.
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones.
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 2ª y 4ª fila más los de la 1ª fila.
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2 % Malla con paso h igual a 0.05 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 2 posiciones.
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

% Este parte representa gráficamente los diferentes mallados para cada paso.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Este trozo dibuja gráficamente los nodos de las mallas menos finas y los de la malla más fina. Esta parte sirve para comprobar que la relación entre los nodos está bien escrita. O sea, si el nodo i de la malla menos fina se corresponde al nodo j de la malla más fina.

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end
}}

El siguiente código realiza la malla del cuadrado de 2 triángulos. Es el mismo código que el anterior pero modificado ligeramente. La idea para la numeración es la misma pero modifica a esta forma de mallado.

{{matlab|codigo=

a = 0;
b = 1;

H = [0.1 0.05 0.025];

V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt','Relacion_malla3malla3_tipo1.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
n = length(x);

% Crea el documento para los nodos.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for j = 1:n
for i = 1:n
nodo = [(j-1)*n + i, x(i), x(j)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
fclose(Verticesdoc);

% Crea el documento para los elementos.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:n-1
for j = 1:n-1
triang = [(2*(j-1)+1)+(n-1)*(i-1), n*(i-1)+j, n*(i-1)+j+1, n*i+j];
fprintf(Elementosdoc,formatSpec,triang);
triang = [(2*(j-1)+2)+(n-1)*(i-1), n*i+j+1, n*i+j, n*(i-1)+j+1];
fprintf(Elementosdoc,formatSpec,triang);
end
end
fclose(Elementosdoc);

% Crea el documento para los nodos de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,1+n*(j-1));
else
fprintf(Dirichletdoc,formatSpec,n+n*(j-1));
end
end

end
fclose(Dirichletdoc);

% Crea el documento para la relación entre las mallas de 2 triángulos con la malla de 4 triángulos con paso h igual a 0.025.

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
for j = 1:n
c = 8*(i-1)+1;
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 4*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
else
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 2*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+j];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
end

% Representa las diferentes mallas.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Representa los nodos de la relación para la comprobación.

for p = 1:3
Vertices = load(V{p});
Elememtos = load(E{p});
Vert = load('Vertices_malla3_tipo1.txt');
Elem = load('Elementos_malla3_tipo1.txt');
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,2);
coord2 = zeros(size(Vert,1),2);
nodos2 = zeros(size(Elem,1),3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+4)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,1),1),coord(Rel(:,1),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,2),1),coord2(Rel(:,2),2),'r.','MarkerSize',20);
hold off
end
}}

Lo siguientes códigos realizan el MEF. Primero se muestra con las mallas de 4 triángulos.

{{matlab|codigo=

% Documentos donde se encuentra la información de las mallas.

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

% Lado del cuadrado inicial.

a = 0;
b = 1;

% Condiciones de tipo Dirichlet.

p0 = 0.5;
p1 = 0;

% Datos del problema.

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

% Matrices empleadas para calcular la matriz de rigidez por ensamblado.

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

% Variables de la tabla final sobre la convergencia.

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

% Resolución del problema para las mallas de cada paso.

for p =1:3

% Lectura de los documentos y creación de variables con los datos de estos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Matrices del problema en forma matricial.

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación valores a la solución de los nodos de la frontera Dirichlet.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir)); % Nodos cuya solución hay que calcular

% Ensamblado de la matriz de rigidez y el vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3 % Aproximación de la integral de f y K sobre cada elemento como un promedio.
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir % Ajuste del vector de cargas.
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind); % Resolución del problema matricial.

Sol(1:length(u),p) = u;

% Representación de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');

end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden en las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})

}}

Ahora, se muestra el mismo código pero ajustado con la parte de convergencia ajustada para comparar con la malla de 4 triángulos más fina.

{{matlab|codigo=
V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt', 'Relacion_malla3malla3_tipo1.txt'};

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
Exacta = zeros(length(a:H(end):b),1);
coord5 = zeros(length(a:H(end):b),1);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:4

% Lectura de documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

if p ==3 % Almacenamos las coordenadas de la malla de 2 triángulos más fina para uso posterior.
coord5 = coord;
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de variables con valores conocidos

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

if p == 4 % Almacenamos la solución de la malla de 4 triángulos en una variable diferente.
Exacta(1:length(u)) = u;
else
Sol(1:length(u),p) = u;
end

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');
end

% Representación gráfica de la diferencia entre la solución de la malla de 2 triángulos más fina con la solución de la malla de 4 triángulos más fina.

Rel = load(R{3});
Elementos= load(E{3});
figure(p+1)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(Elementos(:,2:end),coord5(:,1),coord5(:,2),abs(Sol(:,3)-Exacta(Rel(:,2))));view(0,90);
colorbar;
title('|u-u_h|');

% Creación de variables necesarias para la convergencia.

Vert = load(V{4});
Elem = load(E{4});
M4 = size(Vert,1);
Nel4 = size(Elem,1);
coord4 = zeros(M4,2);
nodos4 = zeros(Nel4,3);
for i = 1:M4
for j = 1:2
coord4(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel4
for j = 1:3
nodos4(i,j) = Elem(i,j+1);
end
end

% Cálculo de la convergencia.

for p = 1:3
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas de 2 triángulos con la solución de la malla de 4 triángulos más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk4 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk4(j,k) = coord4(Rel(nodosK(k+1),2),j)-coord4(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk4 = det(Bk4);
invBk4 = inv(Bk4);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk4 = [Exacta(Rel(nodosK(2),2))-Exacta(Rel(nodosK(1),2)); Exacta(Rel(nodosK(3),2))-Exacta(Rel(nodosK(1),2))];
for j = 1:3
sumL = sumL + (Exacta(Rel(nodosK(j),2)) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk4'*uk4 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

for i = 1:2
ordenL(i) = log(normL(i)/normL(i+1))/log(2);
ordenH(i) = log(normH(i)/normH(i+1))/log(2);
end

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

Por último, se muestra de nuevo el código pero modificado para el nuevo dominio.

{{matlab|codigo=

V = {'Vertices_malla1_tipo3.txt', 'Vertices_malla2_tipo3.txt', 'Vertices_malla3_tipo3.txt'};
E = {'Elementos_malla1_tipo3.txt', 'Elementos_malla2_tipo3.txt', 'Elementos_malla3_tipo3.txt'};
D = {'Dirichlet_malla1_tipo3.txt', 'Dirichlet_malla2_tipo3.txt', 'Dirichlet_malla3_tipo3.txt'};
R = {'Relacion_malla1malla3_tipo3.txt', 'Relacion_malla2malla3_tipo3.txt'};

% Lectura de una de las mallas para el cálculo del centroide del dominio.

Vertices = load(V{3});
Elementos = load(E{3});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo del centroide del dominio por cambio de variable al elemento de referencia.

area2 = 0;
xcmintcv = 0;
ycmintcv = 0;
for i = 1:Nel
jac = zeros(2,2);
triang = [nodos(i,1), nodos(i,2), nodos(i,3)];
for j = 1:2
for k = 1:2
jac(j,k) = coord(triang(k+1),j)-coord(triang(1),j);
end
end
detjac = abs((jac(1,1)*jac(2,2))-(jac(1,2)*jac(2,1)));
areael = detjac*(1/2);
area2 = area2 + areael;
intx = @(a,b) jac(1,1)*a + jac(1,2)*b + coord(triang(1),1);
inty = @(a,b) jac(2,1)*a + jac(2,2)*b + coord(triang(1),2);
xcmintcv = xcmintcv + detjac*integral2(intx,0,1,0,@(z) -z+1);
ycmintcv = ycmintcv + detjac*integral2(inty,0,1,0,@(z) -z+1);
end
xcmcv = xcmintcv/area2;
ycmcv = ycmintcv/area2;

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-xcmcv).^2 + (y-ycmcv).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:3

% Lectura de los documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de valores conocidos.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas.

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

Sol(1:length(u),p) = u;

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title(strcat('u_h con h =',num2str(H(p))));
end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la solución de la malla más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Archivo:Poster RoYa2.png

2025-11-16T21:44:52Z

YanWang:

Archivo:Poster RoYa.jpg

2025-11-16T21:41:42Z

YanWang:

Archivo:Poster RoYa.png

2025-11-16T21:40:19Z

YanWang:

Flujo estacionario en medio poroso (RoYa)

2025-11-16T21:32:00Z

YanWang: /* Póster del Trabajo */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

=Códigos de MatLab=

A continuación, se presenta los códigos empleados para la realización del póster.

Para empezar se muestra los código utilizados para generar los documentos necesarios para las diferentes mallas. Para la malla del cuadrado de 4 triángulos se emplea el siguiente código:

{{matlab|codigo=
% Lado del cuadrado inicial.
a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados.

% Nombres de los documentos creados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'}; % Se emplea para los títulos de las gráficas

% Datos fijos necesarios dentro del bucle.
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

% Bucle para crear las diferente mallas para cada paso.

for p = 1:3
h = H(p);
x = a:h:b; % División del lado en trozos de tamaño h
xm = a+(h/2):h:b; % Coordenada x de los centroides de los cuadrados en los que se divide el cuadrado inicial.
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1); % Vector con las coordenadas x de los nodos que forman los cuadrados y su centroide .
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

% Esta parte crea el documento con la numeración de los nodos y sus coordenada x e y.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l % La numeración de los nodos se basa en el número de nodos que ya se han contado dependiendo del nodo en el que me hallo.
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

% Este trozo crea el documento con la numeración de los elementos y los nodos que forman cada elemento.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4 % El primer elemento es el triángulo de la izquierda, el segundo el de abajo, el tercero el de la derecha y el cuarto el de arriba. La numeración
if k == 1 % de los elementos se basa en el número de cuadrados contados dependiendo del nodo del centroide del cuadrado en el que me hallo.
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

% Esta parte crea el documento que contiene la numeración de los nodos que forman parte de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2 % Los nodos que forman parte de la frontera Dirichlet son aquellos cuya coordenada x es igual a 0 o 1.
for j = 1:n % Luego, el número de nodos ya contados es proporcional.
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

% Este trozo de código crea el documento que relaciona los nodos de las mallas menos finas con la malla más fija, es decir, las mallas con paso h igual a 0.1 y 0.05 con la malla con paso h igual a 0.025.

if p == 1 % Malla con paso h igual a 0.1 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1 % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 1ª y 3ª fila.
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones.
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 2ª y 4ª fila más los de la 1ª fila.
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2 % Malla con paso h igual a 0.05 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 2 posiciones.
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

% Este parte representa gráficamente los diferentes mallados para cada paso.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Este trozo dibuja gráficamente los nodos de las mallas menos finas y los de la malla más fina. Esta parte sirve para comprobar que la relación entre los nodos está bien escrita. O sea, si el nodo i de la malla menos fina se corresponde al nodo j de la malla más fina.

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end
}}

El siguiente código realiza la malla del cuadrado de 2 triángulos. Es el mismo código que el anterior pero modificado ligeramente. La idea para la numeración es la misma pero modifica a esta forma de mallado.

{{matlab|codigo=

a = 0;
b = 1;

H = [0.1 0.05 0.025];

V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt','Relacion_malla3malla3_tipo1.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
n = length(x);

% Crea el documento para los nodos.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for j = 1:n
for i = 1:n
nodo = [(j-1)*n + i, x(i), x(j)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
fclose(Verticesdoc);

% Crea el documento para los elementos.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:n-1
for j = 1:n-1
triang = [(2*(j-1)+1)+(n-1)*(i-1), n*(i-1)+j, n*(i-1)+j+1, n*i+j];
fprintf(Elementosdoc,formatSpec,triang);
triang = [(2*(j-1)+2)+(n-1)*(i-1), n*i+j+1, n*i+j, n*(i-1)+j+1];
fprintf(Elementosdoc,formatSpec,triang);
end
end
fclose(Elementosdoc);

% Crea el documento para los nodos de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,1+n*(j-1));
else
fprintf(Dirichletdoc,formatSpec,n+n*(j-1));
end
end

end
fclose(Dirichletdoc);

% Crea el documento para la relación entre las mallas de 2 triángulos con la malla de 4 triángulos con paso h igual a 0.025.

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
for j = 1:n
c = 8*(i-1)+1;
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 4*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
else
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 2*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+j];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
end

% Representa las diferentes mallas.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Representa los nodos de la relación para la comprobación.

for p = 1:3
Vertices = load(V{p});
Elememtos = load(E{p});
Vert = load('Vertices_malla3_tipo1.txt');
Elem = load('Elementos_malla3_tipo1.txt');
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,2);
coord2 = zeros(size(Vert,1),2);
nodos2 = zeros(size(Elem,1),3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+4)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,1),1),coord(Rel(:,1),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,2),1),coord2(Rel(:,2),2),'r.','MarkerSize',20);
hold off
end
}}

Lo siguientes códigos realizan el MEF. Primero se muestra con las mallas de 4 triángulos.

{{matlab|codigo=

% Documentos donde se encuentra la información de las mallas.

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

% Lado del cuadrado inicial.

a = 0;
b = 1;

% Condiciones de tipo Dirichlet.

p0 = 0.5;
p1 = 0;

% Datos del problema.

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

% Matrices empleadas para calcular la matriz de rigidez por ensamblado.

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

% Variables de la tabla final sobre la convergencia.

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

% Resolución del problema para las mallas de cada paso.

for p =1:3

% Lectura de los documentos y creación de variables con los datos de estos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Matrices del problema en forma matricial.

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación valores a la solución de los nodos de la frontera Dirichlet.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir)); % Nodos cuya solución hay que calcular

% Ensamblado de la matriz de rigidez y el vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3 % Aproximación de la integral de f y K sobre cada elemento como un promedio.
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir % Ajuste del vector de cargas.
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind); % Resolución del problema matricial.

Sol(1:length(u),p) = u;

% Representación de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');

end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden en las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})

}}

Ahora, se muestra el mismo código pero ajustado con la parte de convergencia ajustada para comparar con la malla de 4 triángulos más fina.

{{matlab|codigo=
V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt', 'Relacion_malla3malla3_tipo1.txt'};

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
Exacta = zeros(length(a:H(end):b),1);
coord5 = zeros(length(a:H(end):b),1);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:4

% Lectura de documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

if p ==3 % Almacenamos las coordenadas de la malla de 2 triángulos más fina para uso posterior.
coord5 = coord;
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de variables con valores conocidos

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

if p == 4 % Almacenamos la solución de la malla de 4 triángulos en una variable diferente.
Exacta(1:length(u)) = u;
else
Sol(1:length(u),p) = u;
end

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');
end

% Representación gráfica de la diferencia entre la solución de la malla de 2 triángulos más fina con la solución de la malla de 4 triángulos más fina.

Rel = load(R{3});
Elementos= load(E{3});
figure(p+1)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(Elementos(:,2:end),coord5(:,1),coord5(:,2),abs(Sol(:,3)-Exacta(Rel(:,2))));view(0,90);
colorbar;
title('|u-u_h|');

% Creación de variables necesarias para la convergencia.

Vert = load(V{4});
Elem = load(E{4});
M4 = size(Vert,1);
Nel4 = size(Elem,1);
coord4 = zeros(M4,2);
nodos4 = zeros(Nel4,3);
for i = 1:M4
for j = 1:2
coord4(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel4
for j = 1:3
nodos4(i,j) = Elem(i,j+1);
end
end

% Cálculo de la convergencia.

for p = 1:3
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas de 2 triángulos con la solución de la malla de 4 triángulos más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk4 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk4(j,k) = coord4(Rel(nodosK(k+1),2),j)-coord4(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk4 = det(Bk4);
invBk4 = inv(Bk4);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk4 = [Exacta(Rel(nodosK(2),2))-Exacta(Rel(nodosK(1),2)); Exacta(Rel(nodosK(3),2))-Exacta(Rel(nodosK(1),2))];
for j = 1:3
sumL = sumL + (Exacta(Rel(nodosK(j),2)) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk4'*uk4 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

for i = 1:2
ordenL(i) = log(normL(i)/normL(i+1))/log(2);
ordenH(i) = log(normH(i)/normH(i+1))/log(2);
end

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

Por último, se muestra de nuevo el código pero modificado para el nuevo dominio.

{{matlab|codigo=

V = {'Vertices_malla1_tipo3.txt', 'Vertices_malla2_tipo3.txt', 'Vertices_malla3_tipo3.txt'};
E = {'Elementos_malla1_tipo3.txt', 'Elementos_malla2_tipo3.txt', 'Elementos_malla3_tipo3.txt'};
D = {'Dirichlet_malla1_tipo3.txt', 'Dirichlet_malla2_tipo3.txt', 'Dirichlet_malla3_tipo3.txt'};
R = {'Relacion_malla1malla3_tipo3.txt', 'Relacion_malla2malla3_tipo3.txt'};

% Lectura de una de las mallas para el cálculo del centroide del dominio.

Vertices = load(V{3});
Elementos = load(E{3});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo del centroide del dominio por cambio de variable al elemento de referencia.

area2 = 0;
xcmintcv = 0;
ycmintcv = 0;
for i = 1:Nel
jac = zeros(2,2);
triang = [nodos(i,1), nodos(i,2), nodos(i,3)];
for j = 1:2
for k = 1:2
jac(j,k) = coord(triang(k+1),j)-coord(triang(1),j);
end
end
detjac = abs((jac(1,1)*jac(2,2))-(jac(1,2)*jac(2,1)));
areael = detjac*(1/2);
area2 = area2 + areael;
intx = @(a,b) jac(1,1)*a + jac(1,2)*b + coord(triang(1),1);
inty = @(a,b) jac(2,1)*a + jac(2,2)*b + coord(triang(1),2);
xcmintcv = xcmintcv + detjac*integral2(intx,0,1,0,@(z) -z+1);
ycmintcv = ycmintcv + detjac*integral2(inty,0,1,0,@(z) -z+1);
end
xcmcv = xcmintcv/area2;
ycmcv = ycmintcv/area2;

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-xcmcv).^2 + (y-ycmcv).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:3

% Lectura de los documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de valores conocidos.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas.

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

Sol(1:length(u),p) = u;

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title(strcat('u_h con h =',num2str(H(p))));
end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la solución de la malla más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Flujo estacionario en medio poroso (RoYa)

2025-11-16T21:31:33Z

YanWang: /* Póster del Trabajo */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

[[Archivo:Póster_MNEDP_RoYa.jpg]]

=Códigos de MatLab=

A continuación, se presenta los códigos empleados para la realización del póster.

Para empezar se muestra los código utilizados para generar los documentos necesarios para las diferentes mallas. Para la malla del cuadrado de 4 triángulos se emplea el siguiente código:

{{matlab|codigo=
% Lado del cuadrado inicial.
a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados.

% Nombres de los documentos creados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'}; % Se emplea para los títulos de las gráficas

% Datos fijos necesarios dentro del bucle.
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

% Bucle para crear las diferente mallas para cada paso.

for p = 1:3
h = H(p);
x = a:h:b; % División del lado en trozos de tamaño h
xm = a+(h/2):h:b; % Coordenada x de los centroides de los cuadrados en los que se divide el cuadrado inicial.
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1); % Vector con las coordenadas x de los nodos que forman los cuadrados y su centroide .
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

% Esta parte crea el documento con la numeración de los nodos y sus coordenada x e y.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l % La numeración de los nodos se basa en el número de nodos que ya se han contado dependiendo del nodo en el que me hallo.
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

% Este trozo crea el documento con la numeración de los elementos y los nodos que forman cada elemento.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4 % El primer elemento es el triángulo de la izquierda, el segundo el de abajo, el tercero el de la derecha y el cuarto el de arriba. La numeración
if k == 1 % de los elementos se basa en el número de cuadrados contados dependiendo del nodo del centroide del cuadrado en el que me hallo.
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

% Esta parte crea el documento que contiene la numeración de los nodos que forman parte de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2 % Los nodos que forman parte de la frontera Dirichlet son aquellos cuya coordenada x es igual a 0 o 1.
for j = 1:n % Luego, el número de nodos ya contados es proporcional.
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

% Este trozo de código crea el documento que relaciona los nodos de las mallas menos finas con la malla más fija, es decir, las mallas con paso h igual a 0.1 y 0.05 con la malla con paso h igual a 0.025.

if p == 1 % Malla con paso h igual a 0.1 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1 % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 1ª y 3ª fila.
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones.
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 2ª y 4ª fila más los de la 1ª fila.
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2 % Malla con paso h igual a 0.05 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 2 posiciones.
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

% Este parte representa gráficamente los diferentes mallados para cada paso.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Este trozo dibuja gráficamente los nodos de las mallas menos finas y los de la malla más fina. Esta parte sirve para comprobar que la relación entre los nodos está bien escrita. O sea, si el nodo i de la malla menos fina se corresponde al nodo j de la malla más fina.

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end
}}

El siguiente código realiza la malla del cuadrado de 2 triángulos. Es el mismo código que el anterior pero modificado ligeramente. La idea para la numeración es la misma pero modifica a esta forma de mallado.

{{matlab|codigo=

a = 0;
b = 1;

H = [0.1 0.05 0.025];

V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt','Relacion_malla3malla3_tipo1.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
n = length(x);

% Crea el documento para los nodos.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for j = 1:n
for i = 1:n
nodo = [(j-1)*n + i, x(i), x(j)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
fclose(Verticesdoc);

% Crea el documento para los elementos.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:n-1
for j = 1:n-1
triang = [(2*(j-1)+1)+(n-1)*(i-1), n*(i-1)+j, n*(i-1)+j+1, n*i+j];
fprintf(Elementosdoc,formatSpec,triang);
triang = [(2*(j-1)+2)+(n-1)*(i-1), n*i+j+1, n*i+j, n*(i-1)+j+1];
fprintf(Elementosdoc,formatSpec,triang);
end
end
fclose(Elementosdoc);

% Crea el documento para los nodos de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,1+n*(j-1));
else
fprintf(Dirichletdoc,formatSpec,n+n*(j-1));
end
end

end
fclose(Dirichletdoc);

% Crea el documento para la relación entre las mallas de 2 triángulos con la malla de 4 triángulos con paso h igual a 0.025.

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
for j = 1:n
c = 8*(i-1)+1;
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 4*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
else
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 2*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+j];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
end

% Representa las diferentes mallas.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Representa los nodos de la relación para la comprobación.

for p = 1:3
Vertices = load(V{p});
Elememtos = load(E{p});
Vert = load('Vertices_malla3_tipo1.txt');
Elem = load('Elementos_malla3_tipo1.txt');
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,2);
coord2 = zeros(size(Vert,1),2);
nodos2 = zeros(size(Elem,1),3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+4)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,1),1),coord(Rel(:,1),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,2),1),coord2(Rel(:,2),2),'r.','MarkerSize',20);
hold off
end
}}

Lo siguientes códigos realizan el MEF. Primero se muestra con las mallas de 4 triángulos.

{{matlab|codigo=

% Documentos donde se encuentra la información de las mallas.

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

% Lado del cuadrado inicial.

a = 0;
b = 1;

% Condiciones de tipo Dirichlet.

p0 = 0.5;
p1 = 0;

% Datos del problema.

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

% Matrices empleadas para calcular la matriz de rigidez por ensamblado.

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

% Variables de la tabla final sobre la convergencia.

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

% Resolución del problema para las mallas de cada paso.

for p =1:3

% Lectura de los documentos y creación de variables con los datos de estos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Matrices del problema en forma matricial.

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación valores a la solución de los nodos de la frontera Dirichlet.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir)); % Nodos cuya solución hay que calcular

% Ensamblado de la matriz de rigidez y el vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3 % Aproximación de la integral de f y K sobre cada elemento como un promedio.
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir % Ajuste del vector de cargas.
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind); % Resolución del problema matricial.

Sol(1:length(u),p) = u;

% Representación de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');

end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden en las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})

}}

Ahora, se muestra el mismo código pero ajustado con la parte de convergencia ajustada para comparar con la malla de 4 triángulos más fina.

{{matlab|codigo=
V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt', 'Relacion_malla3malla3_tipo1.txt'};

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
Exacta = zeros(length(a:H(end):b),1);
coord5 = zeros(length(a:H(end):b),1);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:4

% Lectura de documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

if p ==3 % Almacenamos las coordenadas de la malla de 2 triángulos más fina para uso posterior.
coord5 = coord;
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de variables con valores conocidos

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

if p == 4 % Almacenamos la solución de la malla de 4 triángulos en una variable diferente.
Exacta(1:length(u)) = u;
else
Sol(1:length(u),p) = u;
end

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');
end

% Representación gráfica de la diferencia entre la solución de la malla de 2 triángulos más fina con la solución de la malla de 4 triángulos más fina.

Rel = load(R{3});
Elementos= load(E{3});
figure(p+1)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(Elementos(:,2:end),coord5(:,1),coord5(:,2),abs(Sol(:,3)-Exacta(Rel(:,2))));view(0,90);
colorbar;
title('|u-u_h|');

% Creación de variables necesarias para la convergencia.

Vert = load(V{4});
Elem = load(E{4});
M4 = size(Vert,1);
Nel4 = size(Elem,1);
coord4 = zeros(M4,2);
nodos4 = zeros(Nel4,3);
for i = 1:M4
for j = 1:2
coord4(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel4
for j = 1:3
nodos4(i,j) = Elem(i,j+1);
end
end

% Cálculo de la convergencia.

for p = 1:3
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas de 2 triángulos con la solución de la malla de 4 triángulos más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk4 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk4(j,k) = coord4(Rel(nodosK(k+1),2),j)-coord4(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk4 = det(Bk4);
invBk4 = inv(Bk4);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk4 = [Exacta(Rel(nodosK(2),2))-Exacta(Rel(nodosK(1),2)); Exacta(Rel(nodosK(3),2))-Exacta(Rel(nodosK(1),2))];
for j = 1:3
sumL = sumL + (Exacta(Rel(nodosK(j),2)) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk4'*uk4 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

for i = 1:2
ordenL(i) = log(normL(i)/normL(i+1))/log(2);
ordenH(i) = log(normH(i)/normH(i+1))/log(2);
end

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

Por último, se muestra de nuevo el código pero modificado para el nuevo dominio.

{{matlab|codigo=

V = {'Vertices_malla1_tipo3.txt', 'Vertices_malla2_tipo3.txt', 'Vertices_malla3_tipo3.txt'};
E = {'Elementos_malla1_tipo3.txt', 'Elementos_malla2_tipo3.txt', 'Elementos_malla3_tipo3.txt'};
D = {'Dirichlet_malla1_tipo3.txt', 'Dirichlet_malla2_tipo3.txt', 'Dirichlet_malla3_tipo3.txt'};
R = {'Relacion_malla1malla3_tipo3.txt', 'Relacion_malla2malla3_tipo3.txt'};

% Lectura de una de las mallas para el cálculo del centroide del dominio.

Vertices = load(V{3});
Elementos = load(E{3});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo del centroide del dominio por cambio de variable al elemento de referencia.

area2 = 0;
xcmintcv = 0;
ycmintcv = 0;
for i = 1:Nel
jac = zeros(2,2);
triang = [nodos(i,1), nodos(i,2), nodos(i,3)];
for j = 1:2
for k = 1:2
jac(j,k) = coord(triang(k+1),j)-coord(triang(1),j);
end
end
detjac = abs((jac(1,1)*jac(2,2))-(jac(1,2)*jac(2,1)));
areael = detjac*(1/2);
area2 = area2 + areael;
intx = @(a,b) jac(1,1)*a + jac(1,2)*b + coord(triang(1),1);
inty = @(a,b) jac(2,1)*a + jac(2,2)*b + coord(triang(1),2);
xcmintcv = xcmintcv + detjac*integral2(intx,0,1,0,@(z) -z+1);
ycmintcv = ycmintcv + detjac*integral2(inty,0,1,0,@(z) -z+1);
end
xcmcv = xcmintcv/area2;
ycmcv = ycmintcv/area2;

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-xcmcv).^2 + (y-ycmcv).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:3

% Lectura de los documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de valores conocidos.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas.

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

Sol(1:length(u),p) = u;

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title(strcat('u_h con h =',num2str(H(p))));
end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la solución de la malla más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Flujo estacionario en medio poroso (RoYa)

2025-11-16T20:21:42Z

YanWang: /* Códigos de MatLab */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

=Códigos de MatLab=

A continuación, se presenta los códigos empleados para la realización del póster.

Para empezar se muestra los código utilizados para generar los documentos necesarios para las diferentes mallas. Para la malla del cuadrado de 4 triángulos se emplea el siguiente código:

{{matlab|codigo=
% Lado del cuadrado inicial.
a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados.

% Nombres de los documentos creados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'}; % Se emplea para los títulos de las gráficas

% Datos fijos necesarios dentro del bucle.
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

% Bucle para crear las diferente mallas para cada paso.

for p = 1:3
h = H(p);
x = a:h:b; % División del lado en trozos de tamaño h
xm = a+(h/2):h:b; % Coordenada x de los centroides de los cuadrados en los que se divide el cuadrado inicial.
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1); % Vector con las coordenadas x de los nodos que forman los cuadrados y su centroide .
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

% Esta parte crea el documento con la numeración de los nodos y sus coordenada x e y.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l % La numeración de los nodos se basa en el número de nodos que ya se han contado dependiendo del nodo en el que me hallo.
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

% Este trozo crea el documento con la numeración de los elementos y los nodos que forman cada elemento.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4 % El primer elemento es el triángulo de la izquierda, el segundo el de abajo, el tercero el de la derecha y el cuarto el de arriba. La numeración
if k == 1 % de los elementos se basa en el número de cuadrados contados dependiendo del nodo del centroide del cuadrado en el que me hallo.
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

% Esta parte crea el documento que contiene la numeración de los nodos que forman parte de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2 % Los nodos que forman parte de la frontera Dirichlet son aquellos cuya coordenada x es igual a 0 o 1.
for j = 1:n % Luego, el número de nodos ya contados es proporcional.
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

% Este trozo de código crea el documento que relaciona los nodos de las mallas menos finas con la malla más fija, es decir, las mallas con paso h igual a 0.1 y 0.05 con la malla con paso h igual a 0.025.

if p == 1 % Malla con paso h igual a 0.1 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1 % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 1ª y 3ª fila.
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones.
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 2ª y 4ª fila más los de la 1ª fila.
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2 % Malla con paso h igual a 0.05 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 2 posiciones.
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

% Este parte representa gráficamente los diferentes mallados para cada paso.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Este trozo dibuja gráficamente los nodos de las mallas menos finas y los de la malla más fina. Esta parte sirve para comprobar que la relación entre los nodos está bien escrita. O sea, si el nodo i de la malla menos fina se corresponde al nodo j de la malla más fina.

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end
}}

El siguiente código realiza la malla del cuadrado de 2 triángulos. Es el mismo código que el anterior pero modificado ligeramente. La idea para la numeración es la misma pero modifica a esta forma de mallado.

{{matlab|codigo=

a = 0;
b = 1;

H = [0.1 0.05 0.025];

V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt','Relacion_malla3malla3_tipo1.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
n = length(x);

% Crea el documento para los nodos.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for j = 1:n
for i = 1:n
nodo = [(j-1)*n + i, x(i), x(j)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
fclose(Verticesdoc);

% Crea el documento para los elementos.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:n-1
for j = 1:n-1
triang = [(2*(j-1)+1)+(n-1)*(i-1), n*(i-1)+j, n*(i-1)+j+1, n*i+j];
fprintf(Elementosdoc,formatSpec,triang);
triang = [(2*(j-1)+2)+(n-1)*(i-1), n*i+j+1, n*i+j, n*(i-1)+j+1];
fprintf(Elementosdoc,formatSpec,triang);
end
end
fclose(Elementosdoc);

% Crea el documento para los nodos de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,1+n*(j-1));
else
fprintf(Dirichletdoc,formatSpec,n+n*(j-1));
end
end

end
fclose(Dirichletdoc);

% Crea el documento para la relación entre las mallas de 2 triángulos con la malla de 4 triángulos con paso h igual a 0.025.

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
for j = 1:n
c = 8*(i-1)+1;
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 4*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
else
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 2*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+j];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
end

% Representa las diferentes mallas.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Representa los nodos de la relación para la comprobación.

for p = 1:3
Vertices = load(V{p});
Elememtos = load(E{p});
Vert = load('Vertices_malla3_tipo1.txt');
Elem = load('Elementos_malla3_tipo1.txt');
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,2);
coord2 = zeros(size(Vert,1),2);
nodos2 = zeros(size(Elem,1),3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+4)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,1),1),coord(Rel(:,1),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,2),1),coord2(Rel(:,2),2),'r.','MarkerSize',20);
hold off
end
}}

Lo siguientes códigos realizan el MEF. Primero se muestra con las mallas de 4 triángulos.

{{matlab|codigo=

% Documentos donde se encuentra la información de las mallas.

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

% Lado del cuadrado inicial.

a = 0;
b = 1;

% Condiciones de tipo Dirichlet.

p0 = 0.5;
p1 = 0;

% Datos del problema.

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

% Matrices empleadas para calcular la matriz de rigidez por ensamblado.

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

% Variables de la tabla final sobre la convergencia.

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

% Resolución del problema para las mallas de cada paso.

for p =1:3

% Lectura de los documentos y creación de variables con los datos de estos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Matrices del problema en forma matricial.

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación valores a la solución de los nodos de la frontera Dirichlet.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir)); % Nodos cuya solución hay que calcular

% Ensamblado de la matriz de rigidez y el vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3 % Aproximación de la integral de f y K sobre cada elemento como un promedio.
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir % Ajuste del vector de cargas.
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind); % Resolución del problema matricial.

Sol(1:length(u),p) = u;

% Representación de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');

end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden en las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})

}}

Ahora, se muestra el mismo código pero ajustado con la parte de convergencia ajustada para comparar con la malla de 4 triángulos más fina.

{{matlab|codigo=
V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt', 'Relacion_malla3malla3_tipo1.txt'};

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
Exacta = zeros(length(a:H(end):b),1);
coord5 = zeros(length(a:H(end):b),1);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:4

% Lectura de documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

if p ==3 % Almacenamos las coordenadas de la malla de 2 triángulos más fina para uso posterior.
coord5 = coord;
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de variables con valores conocidos

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

if p == 4 % Almacenamos la solución de la malla de 4 triángulos en una variable diferente.
Exacta(1:length(u)) = u;
else
Sol(1:length(u),p) = u;
end

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');
end

% Representación gráfica de la diferencia entre la solución de la malla de 2 triángulos más fina con la solución de la malla de 4 triángulos más fina.

Rel = load(R{3});
Elementos= load(E{3});
figure(p+1)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(Elementos(:,2:end),coord5(:,1),coord5(:,2),abs(Sol(:,3)-Exacta(Rel(:,2))));view(0,90);
colorbar;
title('|u-u_h|');

% Creación de variables necesarias para la convergencia.

Vert = load(V{4});
Elem = load(E{4});
M4 = size(Vert,1);
Nel4 = size(Elem,1);
coord4 = zeros(M4,2);
nodos4 = zeros(Nel4,3);
for i = 1:M4
for j = 1:2
coord4(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel4
for j = 1:3
nodos4(i,j) = Elem(i,j+1);
end
end

% Cálculo de la convergencia.

for p = 1:3
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas de 2 triángulos con la solución de la malla de 4 triángulos más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk4 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk4(j,k) = coord4(Rel(nodosK(k+1),2),j)-coord4(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk4 = det(Bk4);
invBk4 = inv(Bk4);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk4 = [Exacta(Rel(nodosK(2),2))-Exacta(Rel(nodosK(1),2)); Exacta(Rel(nodosK(3),2))-Exacta(Rel(nodosK(1),2))];
for j = 1:3
sumL = sumL + (Exacta(Rel(nodosK(j),2)) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk4'*uk4 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

for i = 1:2
ordenL(i) = log(normL(i)/normL(i+1))/log(2);
ordenH(i) = log(normH(i)/normH(i+1))/log(2);
end

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

Por último, se muestra de nuevo el código pero modificado para el nuevo dominio.

{{matlab|codigo=

V = {'Vertices_malla1_tipo3.txt', 'Vertices_malla2_tipo3.txt', 'Vertices_malla3_tipo3.txt'};
E = {'Elementos_malla1_tipo3.txt', 'Elementos_malla2_tipo3.txt', 'Elementos_malla3_tipo3.txt'};
D = {'Dirichlet_malla1_tipo3.txt', 'Dirichlet_malla2_tipo3.txt', 'Dirichlet_malla3_tipo3.txt'};
R = {'Relacion_malla1malla3_tipo3.txt', 'Relacion_malla2malla3_tipo3.txt'};

% Lectura de una de las mallas para el cálculo del centroide del dominio.

Vertices = load(V{3});
Elementos = load(E{3});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo del centroide del dominio por cambio de variable al elemento de referencia.

area2 = 0;
xcmintcv = 0;
ycmintcv = 0;
for i = 1:Nel
jac = zeros(2,2);
triang = [nodos(i,1), nodos(i,2), nodos(i,3)];
for j = 1:2
for k = 1:2
jac(j,k) = coord(triang(k+1),j)-coord(triang(1),j);
end
end
detjac = abs((jac(1,1)*jac(2,2))-(jac(1,2)*jac(2,1)));
areael = detjac*(1/2);
area2 = area2 + areael;
intx = @(a,b) jac(1,1)*a + jac(1,2)*b + coord(triang(1),1);
inty = @(a,b) jac(2,1)*a + jac(2,2)*b + coord(triang(1),2);
xcmintcv = xcmintcv + detjac*integral2(intx,0,1,0,@(z) -z+1);
ycmintcv = ycmintcv + detjac*integral2(inty,0,1,0,@(z) -z+1);
end
xcmcv = xcmintcv/area2;
ycmcv = ycmintcv/area2;

a = 0;
b = 1;

p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-xcmcv).^2 + (y-ycmcv).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:3

% Lectura de los documentos y creación de variables con dichos datos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación de valores conocidos.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

% Ensamblado de la matriz de rigidez y del vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

% Ajuste del vector de cargas.

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

Sol(1:length(u),p) = u;

% Representación gráfica de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title(strcat('u_h con h =',num2str(H(p))));
end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las normas por aproximación de las soluciones de las mallas menos finas con la solución de la malla más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

% Cálculo del orden de las diferentes normas.

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

% Creación de la tabla de convergencia con los datos calculados.

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Flujo estacionario en medio poroso (RoYa)

2025-11-16T20:04:33Z

YanWang: /* Códigos de MatLab */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

=Códigos de MatLab=

A continuación, se presenta los códigos empleados para la realización del póster.

Para empezar se muestra los código utilizados para generar los documentos necesarios para las diferentes mallas. Para la malla del cuadrado de 4 triángulos se emplea el siguiente código:

{{matlab|codigo=
% Lado del cuadrado inicial.
a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados.

% Nombres de los documentos creados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'}; % Se emplea para los títulos de las gráficas

% Datos fijos necesarios dentro del bucle.
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

% Bucle para crear las diferente mallas para cada paso.

for p = 1:3
h = H(p);
x = a:h:b; % División del lado en trozos de tamaño h
xm = a+(h/2):h:b; % Coordenada x de los centroides de los cuadrados en los que se divide el cuadrado inicial.
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1); % Vector con las coordenadas x de los nodos que forman los cuadrados y su centroide .
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

% Esta parte crea el documento con la numeración de los nodos y sus coordenada x e y.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l % La numeración de los nodos se basa en el número de nodos que ya se han contado dependiendo del nodo en el que me hallo.
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

% Este trozo crea el documento con la numeración de los elementos y los nodos que forman cada elemento.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4 % El primer elemento es el triángulo de la izquierda, el segundo el de abajo, el tercero el de la derecha y el cuarto el de arriba. La numeración
if k == 1 % de los elementos se basa en el número de cuadrados contados dependiendo del nodo del centroide del cuadrado en el que me hallo.
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

% Esta parte crea el documento que contiene la numeración de los nodos que forman parte de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2 % Los nodos que forman parte de la frontera Dirichlet son aquellos cuya coordenada x es igual a 0 o 1.
for j = 1:n % Luego, el número de nodos ya contados es proporcional.
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

% Este trozo de código crea el documento que relaciona los nodos de las mallas menos finas con la malla más fija, es decir, las mallas con paso h igual a 0.1 y 0.05 con la malla con paso h igual a 0.025.

if p == 1 % Malla con paso h igual a 0.1 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1 % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 1ª y 3ª fila.
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones.
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else % La relación entre los primeros nodos de cada fila impar es proporcional al número de nodos que se han contado entre la 2ª y 4ª fila más los de la 1ª fila.
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2 % Malla con paso h igual a 0.05 con la malla más fina.
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n % En cada fila, la relación entre los nodos es un desplazamiento de 2 posiciones.
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m % En cada fila, la relación entre los nodos es un desplazamiento de 4 posiciones empezando por un pequeño desplazamiento.
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

% Este parte representa gráficamente los diferentes mallados para cada paso.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Este trozo dibuja gráficamente los nodos de las mallas menos finas y los de la malla más fina. Esta parte sirve para comprobar que la relación entre los nodos está bien escrita. O sea, si el nodo i de la malla menos fina se corresponde al nodo j de la malla más fina.

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end
}}

El siguiente código realiza la malla del cuadrado de 2 triángulos. Es el mismo código que el anterior pero modificado ligeramente. La idea para la numeración es la misma pero modifica a esta forma de mallado.

{{matlab|codigo=

a = 0;
b = 1;

H = [0.1 0.05 0.025];

V = {'Vertices_malla1_tipo2.txt', 'Vertices_malla2_tipo2.txt', 'Vertices_malla3_tipo2.txt'};
E = {'Elementos_malla1_tipo2.txt', 'Elementos_malla2_tipo2.txt', 'Elementos_malla3_tipo2.txt'};
D = {'Dirichlet_malla1_tipo2.txt', 'Dirichlet_malla2_tipo2.txt', 'Dirichlet_malla3_tipo2.txt'};
R = {'Relacion_malla1malla3_tipo1.txt', 'Relacion_malla2malla3_tipo1.txt','Relacion_malla3malla3_tipo1.txt'};

T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
n = length(x);

% Crea el documento para los nodos.

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for j = 1:n
for i = 1:n
nodo = [(j-1)*n + i, x(i), x(j)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
fclose(Verticesdoc);

% Crea el documento para los elementos.

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:n-1
for j = 1:n-1
triang = [(2*(j-1)+1)+(n-1)*(i-1), n*(i-1)+j, n*(i-1)+j+1, n*i+j];
fprintf(Elementosdoc,formatSpec,triang);
triang = [(2*(j-1)+2)+(n-1)*(i-1), n*i+j+1, n*i+j, n*(i-1)+j+1];
fprintf(Elementosdoc,formatSpec,triang);
end
end
fclose(Elementosdoc);

% Crea el documento para los nodos de la frontera Dirichlet.

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,1+n*(j-1));
else
fprintf(Dirichletdoc,formatSpec,n+n*(j-1));
end
end

end
fclose(Dirichletdoc);

% Crea el documento para la relación entre las mallas de 2 triángulos con la malla de 4 triángulos con paso h igual a 0.025.

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
for j = 1:n
c = 8*(i-1)+1;
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 4*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
else
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:n
c = 2*(i-1)+1;
for j = 1:n
nodo = [(i-1)*n + j, (n2+m2)*(c-1)/2+j];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
fclose(Relaciondoc);
end

% Representa las diferentes mallas.

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

% Representa los nodos de la relación para la comprobación.

for p = 1:3
Vertices = load(V{p});
Elememtos = load(E{p});
Vert = load('Vertices_malla3_tipo1.txt');
Elem = load('Elementos_malla3_tipo1.txt');
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,2);
coord2 = zeros(size(Vert,1),2);
nodos2 = zeros(size(Elem,1),3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+4)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,1),1),coord(Rel(:,1),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,2),1),coord2(Rel(:,2),2),'r.','MarkerSize',20);
hold off
end
}}

Lo siguientes códigos realizan el MEF. Primero se muestra con las mallas de 4 triángulos.

{{matlab|codigo=

% Documentos donde se encuentra la información de las mallas.

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};

% Lado del cuadrado inicial.

a = 0;
b = 1;

% Condiciones de tipo Dirichlet.

p0 = 0.5;
p1 = 0;

% Datos del problema.

f = @(x,y) 50*exp(-100*((x-0.5).^2 + (y-0.5).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

% Matrices empleadas para calcular la matriz de rigidez por ensamblado.

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

% Variables de la tabla final sobre la convergencia.

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

% Resolución del problema para las mallas de cada paso.

for p =1:3

% Lectura de los documentos y creación de variables con los datos de estos.

Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Matrices del problema en forma matricial.

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

% Asignación valores a la solución de los nodos de la frontera Dirichlet.

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir)); % Nodos cuya solución hay que calcular

% Ensamblado de la matriz de rigidez y el vector de cargas.

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3 % Aproximación de la integral de f y K sobre cada elemento como un promedio.
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir % Ajuste del vector de cargas.
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind); % Resolución del problema matricial.

Sol(1:length(u),p) = u;

% Representación de la solución calculada.

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title('u_h');

end

% Cálculo de la convergencia.

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

% Cálculo de las integrales por aproximación de las soluciones de las mallas menos finas con la más fina.

intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

table(H',normL',ordenL',normH',ordenH',condA','VariableNames',{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})

}}

Ahora, se muestra el mismo código pero ajustado con la parte de convergencia ajustada para comparar con la malla de 4 triángulos más fina.

{{matlab|codigo=
V = {'Vertices_malla1_tipo3.txt', 'Vertices_malla2_tipo3.txt', 'Vertices_malla3_tipo3.txt'};
E = {'Elementos_malla1_tipo3.txt', 'Elementos_malla2_tipo3.txt', 'Elementos_malla3_tipo3.txt'};
D = {'Dirichlet_malla1_tipo3.txt', 'Dirichlet_malla2_tipo3.txt', 'Dirichlet_malla3_tipo3.txt'};
R = {'Relacion_malla1malla3_tipo3.txt', 'Relacion_malla2malla3_tipo3.txt'};

Vertices = load(V{3});
Elementos = load(E{3});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

area2 = 0;
xcmintcv = 0;
ycmintcv = 0;
for i = 1:Nel
jac = zeros(2,2);
triang = [nodos(i,1), nodos(i,2), nodos(i,3)];
for j = 1:2
for k = 1:2
jac(j,k) = coord(triang(k+1),j)-coord(triang(1),j);
end
end
detjac = abs((jac(1,1)*jac(2,2))-(jac(1,2)*jac(2,1)));
areael = detjac*(1/2);
area2 = area2 + areael;
intx = @(a,b) jac(1,1)*a + jac(1,2)*b + coord(triang(1),1);
inty = @(a,b) jac(2,1)*a + jac(2,2)*b + coord(triang(1),2);
xcmintcv = xcmintcv + detjac*integral2(intx,0,1,0,@(z) -z+1);
ycmintcv = ycmintcv + detjac*integral2(inty,0,1,0,@(z) -z+1);
end
xcmcv = xcmintcv/area2;
ycmcv = ycmintcv/area2;

a = 0;
b = 1;
p0 = 0.5;
p1 = 0;

f = @(x,y) 50*exp(-100*((x-xcmcv).^2 + (y-ycmcv).^2));
K = @(x,y) 1 + 0.5.*cos(2*pi*x).*cos(2*pi*y);

Lxx = zeros(3,3); Lxx(1,1) = 1/2; Lxx(2,2) = 1/2; Lxx(1,2) = -1/2; Lxx(2,1) = -1/2;
Lyy = zeros(3,3); Lyy(1,1) = 1/2; Lyy(3,3) = 1/2; Lyy(3,1) = -1/2; Lyy(1,3) = -1/2;
Lxy = zeros(3,3); Lxy(1,1) = 1/2; Lxy(2,3) = 1/2; Lxy(1,3) = -1/2; Lxy(2,1) = -1/2;
l0 = (1/6)*ones(3,1);

H = [0.1 0.05 0.025];
Sol = zeros(length(a:H(end):b),3);
normL = zeros(size(H));
ordenL = zeros(size(H));
normH = zeros(size(H));
ordenH = zeros(size(H));
condA = zeros(size(H));

for p =1:3
Dir = load(D{p});
Vertices = load(V{p});
Elementos = load(E{p});
MDir = length(Dir);
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

A = zeros(M,M);
b = zeros(M,1);
u = zeros(M,1);

for i = 1:length(Dir)
if coord(Dir(i),1) == a
u(Dir(i)) = p0;
else
u(Dir(i)) = p1;
end
end

ind = setdiff(1:M,sort(Dir));

for e = 1:Nel
nodosK = Elementos(e, 2:end);
Bk = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
Ck = invBk*invBk';
fk = 0;
Kk = 0;
for i = 1:3
Kk = Kk + K(coord(nodosK(i),1),coord(nodosK(i),2));
fk = fk + f(coord(nodosK(i),1),coord(nodosK(i),2));
end
Kk = Kk./3;
fk = fk./3;
Lk = abs(detBk)*Kk*(Ck(1,1)*Lxx + Ck(1,2)*(Lxy+Lxy') + Ck(2,2)*Lyy);
A(nodosK,nodosK) = A(nodosK,nodosK) + Lk;
lk = fk*abs(detBk)*l0;
b(nodosK) = b(nodosK) + lk;
end

for i = 1:M-MDir
camb = 0;
for j = 1:MDir
camb = camb + A(Dir(j),ind(i))*u(Dir(j));
end
b(ind(i)) = b(ind(i)) - camb;
end

u(ind) = A(ind,ind)\b(ind);

Sol(1:length(u),p) = u;

figure(p)
xlim([min(coord(:,1)) max(coord(:,1))]);
ylim([min(coord(:,2)) max(coord(:,2))]);
grid on
trisurf(nodos,coord(:,1),coord(:,2),u);view(0,90);
colorbar;
title(strcat('u_h con h =',num2str(H(p))));

end

for p = 1:2
Rel = load(R{p});
Vertices = load(V{p});
Elementos = load(E{p});
Vert = load(V{end});
M = size(Vertices,1);
M3 = size(Vert,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
coord3 = zeros(M3,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:M3
for j = 1:2
coord3(i,j) = Vert(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end
intL = 0;
intdH = 0;
for i = 1:Nel
nodosK = nodos(i,:);
Bk = zeros(2,2);
Bk3 = zeros(2,2);
for j = 1:2
for k = 1:2
Bk(j,k) = coord(nodosK(k+1),j)-coord(nodosK(1),j);
Bk3(j,k) = coord3(Rel(nodosK(k+1),2),j)-coord3(Rel(nodosK(1),2),j);
end
end
detBk = det(Bk);
invBk = inv(Bk);
detBk3 = det(Bk3);
invBk3 = inv(Bk3);
sumL = 0;
sumdH = 0;
uk = [Sol(nodosK(2),p)-Sol(nodosK(1),p); Sol(nodosK(3),p)-Sol(nodosK(1),p)];
uk3 = [Sol(Rel(nodosK(2),2),3)-Sol(Rel(nodosK(1),2),3); Sol(Rel(nodosK(3),2),3)-Sol(Rel(nodosK(1),2),3)];
for j = 1:3
sumL = sumL + (Sol(Rel(nodosK(j),2),3) - Sol(nodosK(j),p)).^2;
sumdH = sumdH + norm(invBk3'*uk3 - invBk'*uk).^2;
end
intL = intL + (abs(detBk)/3)*sumL;
intdH = intdH + (abs(detBk)/3)*sumdH;
end

normL(p) = sqrt(intL);
normH(p) = sqrt(intL + intdH);
condA(p) = cond(A);
end

ordenL(1) = log(normL(1)/normL(2))/log(2);
ordenH(1) = log(normH(1)/normH(2))/log(2);

table(H',normL',ordenL',normH',ordenH',condA','VariableNames', ...
{'h','norma en L2','orden L2','norma en H1','orden H1','cond(A)'})
}}

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Flujo estacionario en medio poroso (RoYa)

2025-11-16T19:07:41Z

YanWang: /* Códigos de MatLab */

{{ TrabajoED | Flujo estacionario en medio poroso (RoYa) | [[:Categoría:MNEDP|MNEDP]]|[[:Categoría:MNEDP25/26|2025-26]] | Rocío Tajuelo Díaz, Yan Wang}}

=Póster del Trabajo=

=Códigos de MatLab=

a = 0;
b = 1;

H = [0.1 0.05 0.025]; % Pasos considerados

V = {'Vertices_malla1_tipo1.txt', 'Vertices_malla2_tipo1.txt', 'Vertices_malla3_tipo1.txt'};
E = {'Elementos_malla1_tipo1.txt', 'Elementos_malla2_tipo1.txt', 'Elementos_malla3_tipo1.txt'};
D = {'Dirichlet_malla1_tipo1.txt', 'Dirichlet_malla2_tipo1.txt', 'Dirichlet_malla3_tipo1.txt'};
R = {'Relacion_malla1malla3.txt', 'Relacion_malla2malla3.txt'};
T = {'Mallado con h=0.1', 'Mallado con h=0.05', 'Mallado con h=0.025'};

% Datos fijos necesarios dentro del bucle
h = H(3);
X = a:h:b;
Xm = a+(h/2):h:b;
n2 = length(X);
m2 = length(Xm);
l2 = n2+m2;

for p = 1:3
h = H(p);
x = a:h:b;
xm = a+(h/2):h:b;
n = length(x);
m = length(xm);
apoyo = zeros(n+m,1);
for i = 1:n
apoyo(2*(i-1)+1) = x(i);
if i <= m
apoyo(2*i) = xm(i);
end
end
l = length(apoyo);

Verticesdoc = fopen(V{p},'w');
formatSpec = '%d %.4f %.4f \n';
for i = 1:l
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), x(j), apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), xm(j) apoyo(i)];
fprintf(Verticesdoc,formatSpec,nodo);
end
end
end
fclose(Verticesdoc);

Elementosdoc = fopen(E{p},'w');
formatSpec = '%d %d %d %d \n';
for i = 1:m
for j = 1:m
for k = 1:4
if k == 1
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+j, (n+m)*(i-1)+j];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 2
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+j, (n+m)*(i-1)+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
elseif k == 3
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*(i-1)+(j+1), (n+m)*i+(j+1)];
fprintf(Elementosdoc,formatSpec,triang);
else
triang = [(4*(j-1)+k)+40*(i-1), ((n+m)*(i-1)+n)+j, (n+m)*i+(j+1), (n+m)*i+j];
fprintf(Elementosdoc,formatSpec,triang);
end
end
end
end
fclose(Elementosdoc);

Dirichletdoc = fopen(D{p},'w');
formatSpec = '%d \n';
for i = 1:2
for j = 1:n
if i == 1
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+1);
else
fprintf(Dirichletdoc,formatSpec,(n+m)*(j-1)+n);
end
end

end
fclose(Dirichletdoc);

if p == 1
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
if mod(i,2) == 1
for j = 1:n
c = 3*i+2*(floor(i/2)-1);
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+4*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m
c = 4*i-3;
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+4*(j-1)+3];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
elseif p == 2
Relaciondoc = fopen(R{p},'w');
formatSpec = '%d %d \n';
for i = 1:l
c = 2*i-1;
if mod(i,2) == 1
for j = 1:n
nodo = [(((n+m)*(floor(i/2))) + j), (n2+m2)*(c-1)/2+2*(j-1)+1];
fprintf(Relaciondoc,formatSpec,nodo);
end
else
for j = 1:m
nodo = [(((n+m)*(i/2-1) + n) + j), (n2+m2)*((c-1)/2)+2*(j-1)+2];
fprintf(Relaciondoc,formatSpec,nodo);
end
end
end
fclose(Relaciondoc);
end

Vertices = load(V{p});
Elementos = load(E{p});
Dir = load(D{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

figure(p)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Dir,1),coord(Dir,2),'-b','LineWidth',5);
hold on
for i=1:Nel
nod1 = nodos(i,1);
nod2 = nodos(i,2);
nod3 = nodos(i,3);
x =[coord(nod1,1), coord(nod2,1), coord(nod3,1), coord(nod1,1)];
y =[coord(nod1,2), coord(nod2,2), coord(nod3,2), coord(nod1,2)];
fill(x, y, 'cyan')
end
title(T{p})
end

for p = 1:2
Vert = load(V{p});
Elem = load(E{p});
Vertices = load(V{3});
Elementos = load(E{3});
Rel = load(R{p});
M = size(Vertices,1);
Nel = size(Elementos,1);
coord = zeros(M,2);
nodos = zeros(Nel,3);
coord2 = zeros(M,2);
nodos2 = zeros(Nel,3);
for i = 1:M
for j = 1:2
coord(i,j) = Vertices(i,j+1);
end
end

for i = 1:Nel
for j = 1:3
nodos(i,j) = Elementos(i,j+1);
end
end

for i = 1:size(Vert,1)
for j = 1:2
coord2(i,j) = Vert(i,j+1);
end
end

for i = 1:size(Elem,1)
for j = 1:3
nodos2(i,j) = Elem(i,j+1);
end
end

figure(p+3)
xlim([min(coord(:,1)),max(coord(:,1))]);
ylim([min(coord(:,2)),max(coord(:,2))]);
grid on
plot(coord(Rel(:,2),1),coord(Rel(:,2),2),'bx','MarkerSize',20);
hold on
plot(coord2(Rel(:,1),1),coord2(Rel(:,1),2),'r.','MarkerSize',20);
hold off
end

[[Categoría:MNEDP|MNEDP]]
[[Categoría:MNEDP25/26|2025-26]]

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T15:10:40Z

YanWang: /* Solución del problema en dimensión 2 */

{{ TrabajoEDP | Ecuación de Ondas Grupo 9 | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP23/24|2023-24]] | Miguel Cazorla Pedraza
Otelo Gallego Ayala Yan Wang}}

== Ecuación de ondas I ==

La idea principal de este artículo será dibujar diferentes soluciones de la ecuación
de ondas en una dimensión. Para ello, nos basaremos en el enunciado descrito a continuación.

=== Planteamiento del problema ===

Se considera una cuerda vibrante que ocupa el intervalo <math> [0, 1] </math> con densidad <math> d </math> y tensión
<math> \tau_0 </math> constante de manera que la velocidad de propagación es <math> c = \tau_0/d = 1 </math> . Supondremos además que la
cuerda está fija en los extremos. Llamaremos <math> u_0(x) </math> y <math> u_1(x) </math> su posición e impulso iniciales respectivamente.

Lo primero que haremos, será escribir el sistema de EDPS que modeliza el comportamiento de los desplazamiento transversales de la cuerda. Esto es:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u(0,t)=u(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=u_1(x) \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Cuya solución encontrada gracias al método de separación de las variables, el principio de superposición y las condiciones iniciales es

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}\cos(k\pi t)\right]\sin(k\pi x) </math> </center>

donde:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \sin(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \sin(k\pi x) dx</math> </center>

=== Dibujo de la solución dadas las condiciones iniciales ===
Considerando <math> u_0(x,t)= e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = 0</math>, entonces la solución tomando los primeros <math>50 </math> términos de la serie es

<center> <math> u(x,t)=\sum_{k=1}^{50} 2 \left[\int_0^1 u_0(x) \sin(k\pi x) dx\right]cos(k\pi t) \sin(k\pi x) </math> </center>

Y el dibujo de la solución en el intervalo de tiempo <math> [0,2] </math> queda así:

[[Archivo:63ot.png|600px|thumb|center|Solución ecuación de ondas]]

Observamos que en <math>t=0</math> la onda se divide en dos, que viajan hacia cada uno de los extremos espaciales. Cuando llegan a los extremos, cambian de signo y de sentido para volver a <math> x=0.5</math> y cuando se reencuentran mantienen el signo para repetir el recorrido, pero esta vez, cuando llegan a los extremos vuelven a hacerse positivas y en <math>t=2</math> se vuelve al estado inicial. Por ello, la solución para estas condiciones iniciales es periódica en el tiempo con periodo <math> T = 2 </math>.

Esto también se puede apreciar si repetimos el dibujo en el intervalo temporal <math> [0,4] </math>:

[[Archivo:63ot4.png|600px|thumb|center|Solución ecuación de ondas]]

Veamos en un GIF cómo se comporta la onda en función del tiempo:

[[Archivo:Ejercicio63.gif|400px|thumb|center|Onda que viaja en un solo sentido]]

==== Código ====
{{matlab|codigo=
clear all
close all
%Resumen: la idea del programa es crear una matriz de pares (tiempo,
%espacio) y en cada uno de esos puntos calcular la aproximación de la
%solución mediante un bucle for que realiza la suma de términos de la serie
%calculada

%creamos la malla en la que introduciremos las evaluaciones
evaluaciones2 = zeros(100,100);
evaluacionesvideo = zeros(1000,100);
%quedan impuestas los condiciones frontera por ser una matriz de ceros ya
% que posteriormente no modificamos ni la primera ni la última columna

%limite temporal y vectores de tiempos y espacios
T = 2;
t = linspace(0,T,100);
x = linspace(0,1,100);
tp = linspace(0,10,1000);

%funcion de la condicion inicial
cond =@(y) exp(-100.*(y-1/2).^2);

%imponemos la condicion inicial
evaluaciones2(1,:) = cond(x)';
evaluacionesvideo(1,:) = cond(x)';

%en el siguiente bucle for, para cada k calculamos el coeficiente de
%Fourier y sumamos el correspondiente término de la serie en cada punto de
% la malla. Para el cálculo de la integral que nos da el coeficiente de
% Fourier usamos la regla del trapecio con 1000 puntos en [0,1]
for k=1:50
%puntos
N=1000;
%extremos del intervalo
a=0; b=1;
h=(b-a)/N;
%partición del intervalo
u=a:h:b;
%f es la funcion que queremos integrar
f=(cond(u).*sin(k.*pi.*u))';
%vector de pesos
w=ones(N+1,1);
w(1)=1/2; w(N+1)=1/2;
%m es el valor de la integral
m=h*w'*f;
%calculo final de los coeficientes del seno
coef = 2*m;
%sumamos los 100 primeros términos de la serie en cada punto de la
% malla con los nuevos coeficientes
for j =2:99
for i = 2:100
evaluaciones2(i,j) = evaluaciones2(i,j) + coef.*sin(k.*pi.*(x(j))).*cos(k*pi*t(i));
end
for i = 2:1000
evaluacionesvideo(i,j) = evaluacionesvideo(i,j) + coef.*sin(k.*pi.*(x(j))).*cos(k*pi*tp(i));
end
end
end

%plot en 3D
figure(1)
surf(t,x,evaluaciones2')
xlabel('t')
ylabel('x')
zlabel('u(x,t)')

% Crear la animación y guardarla como GIF
% Nombre del archivo GIF
filename = 'Ejercicio63.gif';

% Configuración de la animación
fps = 5; % Fotogramas por segundo
delayTime = 1 / fps; % Tiempo de retraso entre fotogramas

for i = 1:10:1000 % Reducir el número de fotogramas
figure(2);
plot(x,evaluacionesvideo(i,:))
axis([0 1 -1.2 1.2])
xlabel("Espacio")
ylabel("u(x,t)")
title("t = " + mat2str(tp(i)))

% Guardar cada frame como imagen en formato GIF
frame = getframe(gcf);
im = frame2im(frame);
[imind,cm] = rgb2ind(im,64); % Reducir el número de colores

% Escribir en el archivo GIF
if i == 1
imwrite(imind,cm,filename,'gif', 'Loopcount',inf, 'DelayTime', delayTime);
else
imwrite(imind,cm,filename,'gif','WriteMode','append', 'DelayTime', delayTime);
end
end

}}

=== Otros datos iniciales más particulares para el sistema ===
Ahora, consideraremos los datos iniciales correspondientes a una onda que viaja en un sólo sentido <math>\left(u(x,t) = f(x-t)\right) </math>. Para ello, tomamos:

<center> <math> u_0(x) = f(x), \hspace{3mm} u_1(x) = -f'(x) \hspace{2mm} con \hspace{2mm} f(x) = e^{-100(x-1/2)^2} </math> </center>

Es decir, la misma <math>u_0 </math> que antes pero esta vez tomamos como <math>u_1 </math> su derivada respecto el espacio cambiada de signo:

<center> <math> u_0(x) = e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = (200x-100)e^{-100(x-1/2)^2} \hspace{2mm} </math> </center>

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]\sin(k\pi x) </math> </center>

[[Archivo:64ot.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Podemos observar que claramente en el dibujo se muestra una onda que viaja en un solo sentido con longitud de onda <math>\lambda = 2 </math> metros. Por tanto la velocidad es <math>c = \frac{\lambda}{T} = \frac{2}{2} = 1 m/s </math>

La onda parte de <math>x = 0.5 </math>m y se dirige hacia <math>x=1 </math>. En <math>t = 0.5 </math>s llega a esa frontera y allí cambia de signo y de dirección, para dirigirse hacia el extremo <math>x=0</math>, que tarda en alcanzar <math>1 </math>s. Por último, cuando llega a este extremo, pasa de nuevo a tomar valores positivos y toma la dirección inicial para volver a la posición de partida <math>x = 0.5 </math>. De nuevo probando. que el periodo es de <math>2 </math> segundos.

Todo esto se ve mejor observando la onda desde otro ángulo:

[[Archivo:64ot2.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Y además hemos creado un GIF para visualizar la onda respecto al tiempo:

[[Archivo:Ejercicio41.gif|400px|thumb|center|Onda que viaja en un solo sentido]]

==== Código ====

{{matlab|codigo=
clear all
close all

% Resumen: la idea del programa es crear una matriz de pares (tiempo,
% espacio) y en cada uno de esos puntos calcular la aproximación de la
% solución mediante un bucle for que realiza la suma de términos de la serie
% calculada

% Creamos la malla en la que introduciremos las evaluaciones
evaluaciones2 = zeros(1000,100);

% Límite temporal y vectores de tiempos y espacios
T = 2;
t = linspace(0,T,100);
x = linspace(0,1,100);
tp = linspace(0,10,1000);

% Función de la condicion inicial
cond0 =@(y) exp(-100*((y-(1/2)).^2));
cond1 = @(y) 200.*(y-(1/2)).*exp(-100*((y-(1/2)).^2));

% Imponemos la condicion inicial
evaluaciones2(1,:) = cond0(x)';

% En el siguiente bucle for, para cada k calculamos el coeficiente de
% Fourier y sumamos el correspondiente término de la serie en cada punto de
% la malla. Para el cálculo de la integral que nos da el coeficiente de
% Fourier usamos la regla del trapecio con 1000 puntos en [0,1]
for k=1:100
% Puntos
N=1000;
% Extremos del intervalo
a=0; b=1;
h=(b-a)/N;
% Partición del intervalo
u=a:h:b;
% f es la funcion que queremos integrar
f0 = (cond0(u).*sin(k.*pi.*u))';
f1 = (cond1(u).*sin(k.*pi.*u))';
% Vector de pesos
w=ones(N+1,1);
w(1)=1/2; w(N+1)=1/2;
% m es el valor de la integral
m0 = h*w'*f0;
m1 = h*w'*f1;
% Calculo final de los coeficientes del seno
coef0 = 2*m0;
coef1 = 2*m1;
% Sumamos los 100 primeros términos de la serie en cada punto de la
% malla con los nuevos coeficientes
for j =1:99
for i = 2:1000
evaluaciones2(i,j) = evaluaciones2(i,j) + coef0.*sin(k.*pi.*(x(j))).*cos(k.*pi.*(tp(i))) + ...
(1/(k*pi)).*coef1.*sin(k.*pi.*(x(j))).*sin(k.*pi.*(tp(i)));
end
end
end

% Crear la animación y guardarla como GIF
% Nombre del archivo GIF
filename = 'Ejercicio4.gif';

% Configuración de la animación
fps = 5; % Fotogramas por segundo
delayTime = 1 / fps; % Tiempo de retraso entre fotogramas

for i = 1:10:1000 % Reducir el número de fotogramas
figure(1);
plot(x,evaluaciones2(i,:))
axis([0 1 -1.2 1.2])
xlabel("Espacio")
ylabel("u(x,t)")
title("t = " + mat2str(tp(i)))

% Guardar cada frame como imagen en formato GIF
frame = getframe(gcf);
im = frame2im(frame);
[imind,cm] = rgb2ind(im,64); % Reducir el número de colores

% Escribir en el archivo GIF
if i == 1
imwrite(imind,cm,filename,'gif', 'Loopcount',inf, 'DelayTime', delayTime);
else
imwrite(imind,cm,filename,'gif','WriteMode','append', 'DelayTime', delayTime);
end
end

}}

=== Diferencia con la condición Neumann ===
Por último, veremos qué ocurre si repetimos lo anterior cambiando las condiciones Dirichlet por Neumann:

<center> <math> u_x(0,t) = u_x(1,t) = 0 </math> </center>

Con ello, el sistema pasa a ser:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u_x(0,t)=u_x(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=e^{-100(x-1/2)^2}, \hspace{3mm} u_t(x,0)=(200x-100)e^{-100(x-1/2)^2} \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Aplicamos de nuevo separación de las variables y el principio de superposición peor debido al cambio en las condiciones obtenemos esta solución:

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]cos(k\pi x) </math> </center>

donde, ahora:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \cos(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \cos(k\pi x) dx</math> </center>

En este caso, la gráfica de la solución queda así:

[[Archivo:65ot.png|600px|thumb|center|Solución ecuación de ondas]]

En este caso, la velocidad de la onda es la misma y el desplazamiento ocurre en el mismo sentido y dirección. Lo único que cambia es que cuando la onda llega a los extremos del intervalo espacial, en vez de cambiar de signo, aumenta hasta el máximo y regresa al mismo valor con el cambio de dirección. Esto hace que en los extremos se cumpla la condición Neumann que hemos impuesto.

Veamos en un GIF cómo se comporta la onda en función del tiempo:

[[Archivo:Ejercicio63.gif|400px|thumb|center|Onda con condiciones Neumann]]

==== Código ====
{{matlab|codigo=
clear all
close all
%Resumen: la idea del programa es crear una matriz de pares (tiempo,
%espacio) y en cada uno de esos puntos calcular la aproximación de la
%solución mediante un bucle for que realiza la suma de términos de la serie
%calculada

%creamos la malla en la que introduciremos las evaluaciones
evaluaciones2 = zeros(100,100);
evaluacionesvideo = zeros(1000,100);
%quedan impuestas los condiciones frontera por ser una matriz de ceros ya
% que posteriormente no modificamos ni la primera ni la última columna

%limite temporal y vectores de tiempos y espacios
T = 2;
t = linspace(0,T,100);
x = linspace(0,1,100);
tp = linspace(0,10,1000);

%f y f'
cond =@(y) exp(-100.*(y-1/2).^2);
cond2 =@(y) (200.*y-100).*exp(-100.*(y-1/2).^2);

%en el siguiente bucle for, para cada k calculamos el coeficiente de
%Fourier y sumamos el correspondiente término de la serie en cada punto de
% la malla. Para el cálculo de la integral que nos da el coeficiente de
% Fourier usamos la regla del trapecio con 1000 puntos en [0,1]
for k=1:50
%puntos
N=1000;
%extremos del intervalo
a=0; b=1;
h=(b-a)/N;
%partición del intervalo
u=a:h:b;
%f es la funcion que queremos integrar
f=(cond(u).*cos(k.*pi.*u))';
g=(cond2(u).*cos(k.*pi.*u))';
%vector de pesos
w=ones(N+1,1);
w(1)=1/2; w(N+1)=1/2;
%m es el valor de la integral
m=h*w'*f;
n=h*w'*g;
%calculo final de los coeficientes del seno
coef = 2*m;
coef2 = 2*n;
%sumamos los 100 primeros términos de la serie en cada punto de la
% malla con los nuevos coeficientes
for j =1:100
for i = 1:100
evaluaciones2(i,j) = evaluaciones2(i,j) + (coef.*cos(k*pi*t(i)) + coef2/(k*pi).*sin(k*pi*t(i))).*cos(k.*pi.*(x(j)));
end
for i = 1:1000
evaluacionesvideo(i,j) = evaluacionesvideo(i,j) + (coef.*cos(k*pi*tp(i)) + coef2/(k*pi).*sin(k*pi*tp(i))).*cos(k.*pi.*(x(j)));
end
end
end

%plot en 3D
figure(1)
surf(t,x,evaluaciones2')
xlabel('t')
ylabel('x')
zlabel('u(x,t)')

% Crear la animación y guardarla como GIF
% Nombre del archivo GIF
filename = 'Ejercicio65.gif';

% Configuración de la animación
fps = 5; % Fotogramas por segundo
delayTime = 1 / fps; % Tiempo de retraso entre fotogramas

for i = 1:10:1000 % Reducir el número de fotogramas
figure(2);
plot(x,evaluacionesvideo(i,:))
axis([0 1 -1.2 1.2])
xlabel("Espacio")
ylabel("u(x,t)")
title("t = " + mat2str(tp(i)))

% Guardar cada frame como imagen en formato GIF
frame = getframe(gcf);
im = frame2im(frame);
[imind,cm] = rgb2ind(im,64); % Reducir el número de colores

% Escribir en el archivo GIF
if i == 1
imwrite(imind,cm,filename,'gif', 'Loopcount',inf, 'DelayTime', delayTime);
else
imwrite(imind,cm,filename,'gif','WriteMode','append', 'DelayTime', delayTime);
end
end
}}

== Ecuación de ondas II ==

En este apartado dibujaremos la solución fundamental de la ecuación de ondas en dimensiones 1, 2 y 3, lo que nos servirá para interpretar el principio de Huygens.

La solución fundamental es la solución que se obtiene al dar un impulso inicial muy localizado en <math> x=0 </math>. Matemáticamente resuelve el sistema
<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^n, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=\delta (x) \hspace{6mm} x\in \mathbb{R}^n . \\

\end{array}
\right. </math> </center>

Donde <math> \delta (x) </math> es la delta de Dirac. Formalmente, se define como el siguiente límite

<center> <math> \delta (x) = \lim_{r\to 0} \frac{1}{|B(0,r)|}\chi_{B(0,r)}(x) \sim \left\{
\begin{array}{ll}

\infty \hspace{4mm} x=0,\\

0 \hspace{4mm} x\neq 0,\\

\end{array}
\right. </math> </center>

Donde <math> \chi_{B(0,r)}(x) </math> es la función característica de la bola centrada en <math> 0 </math> de radio <math> r </math> y <math> |B(0,r)| </math> es el volumen de la bola.

Su expresión es:

1. En dimensión <math> n=1 </math>:

<center> <math> K_1(x,t)=\frac{1}{2c}[H(x+ct)-H(x-ct)], </math> </center>

Donde <math> H(s)= \left\{
\begin{array}{ll}

0 \hspace{4mm} si \hspace{2mm}s<0,\\

1 \hspace{4mm} si \hspace{2mm} s\geq 0,\\

\end{array}
\right.</math> es la función de Heaviside.

2. En dimensión <math> n=2 </math>:

<center> <math> K_2(x,t)=\frac{1}{2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

donde <math> \chi_{B(0,ct)}(x), </math> es la función característica de la bola de centro 0 y radio <math> ct </math>.

3. En dimensión <math> n=3 </math>:

<center> <math> K_3(x,t)=\frac{\delta (|x|-ct)}{4\pi c |x| }, \hspace{2mm} t>0. </math> </center>

=== Representaciones ===

Antes de nada, nótese que la solución fundamental es radial para todas estas dimensiones. La primera lo es puesto que <math> x\in \mathbb{R}</math>, y las otras dos son radiales porque la variable espacial <math> x </math> aparece siempre en módulo, <math> |x| </math>.

A continuación, dibujamos las dichas soluciones fundamentales:

[[Archivo:Pr471.png|600px|thumb|right|Solución estacionaria]]

{{matlab|codigo=
% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función de Heaviside
H = @(s) double(s >= 0);

% Definir la función K1(x,t)
K1 = @(x, t) (1 / (2 * c)) * (H(x + c * t) - H(x - c * t));

% Rango de valores para x y t
x = linspace(-10, 10, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 10, 1000); % Ajusta el rango y la resolución según lo necesites

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K1 para cada par de valores (x, t)
K1_values = arrayfun(@(x_val, t_val) K1(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K1_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_1(x,t)');
title(['Gráfico de K_1(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

Como podemos ver en la expresión analítica, esta función fundamental tiene una singularidad cuando <math> c^2t^2=|x|^2 </math>. Por ello, para poder representarla añadiremos un sumando <math> \epsilon </math> al denominador, esto es

<center> <math> K_2(x,t)=\frac{1}{\epsilon +2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

Su representación gráfica en función de la variable radial es la dada por la siguiente imagen:

[[Archivo:Pr472.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función característica de la bola de centro 0 y radio ct
chi_B = @(x, t) double(abs(x) <= c * t);

% Definir la función K2(x,t)
K2 = @(x, t) (1 ./ (0.01 + 2 * pi * c * sqrt(c^2 * t.^2 - x.^2))) .* chi_B(x, t);

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K2 para cada par de valores (x, t)
K2_values = arrayfun(@(x_val, t_val) K2(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K2_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_2(x,t)');
title(['Gráfico de K_2(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad

}}

En dimensión <math> n=3 </math>, para poder hacer la representación tendremos que tomar la siguiente aproximación de la delta de Dirac:

<center> <math> \delta(s) \sim \phi _k (s) = \sqrt{\frac{1000}{\pi}e^{-1000s^2}} </math> </center>

Así, su representación queda como sigue:

[[Archivo:pr473.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites
a = 1000; % Constante del exponente

% Definir la función K3(x,t)
K3 = @(x, t) (sqrt((a / pi) * exp(-a * (abs(x) - c * t).^2))) ./ (4 * pi * c * abs(x));

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K3 para cada par de valores (x, t)
K3_values = arrayfun(@(x_val, t_val) K3(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K3_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_3(x,t)');
title(['Gráfico de K_3(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

=== Solución del problema en dimensión 2 ===

La solución del problema:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^2, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)= h(x) = \chi_{B(0,1/2)}(x)\hspace{6mm} x\in \mathbb{R}^2 . \\

\end{array}
\right. </math> </center>

viene dada por la convolución:

<center> <math>u(x,t) = \int_{\mathbb{R}^2} K_2(x-y,t)h(y) dy</math> </center>

Aprovecharemos que la solución es radial para calcularla sólo en los puntos de la forma <math>(x_1,0)</math> con <math>x_1 > 0</math>.Además, para evitar la singularidad de la solución fundamental volveremos a tomar el <math>epsilon<\math> en denominador.

A continuación se muestran los dibujos de las soluciones para <math> t =0, 0.5, 1, 2</math>

[[Archivo:FundamemtalConv.jpg|600px|thumb|center|Solución a partir de la convolución]]

{{matlab|codigo=

t = [0;0.5;1;2]; % Vector de tiempos donde evaluamos la solución
x = linspace(0,3,100); % Vector de discretización del espacio
sols = zeros(length(t),length(x)); % Matriz de valores de la solución en la discretización en los diferentes tiempos

% Cálculo de valores de la solución y representación gráfica
figure(1)
for j=1:length(t)
for i = 1:length(x)
sols(j,i) = g(x(i),t(j));
end
subplot(2,2,j)
plot(x,sols(j,:))
title("Solución para t =" + num2str(t(j)))
xlabel('x1')
ylabel('u((x1,0),t)')
end

% Función que devuelve los valores de la solución por convolución
function valor = g(x,t)
% Definir la función característica de la bola de centro 0 y radio ct
c = 1;
chi_B = @(y) double(abs(y) <= c .* t); % Función característica en la bola de centro 0 y radio ct
chi = @(y) double(abs(y) <= 1/2); % Función característica en la bola de centro 0 y radio 1/2
% Definir la función K2(x,t)
K2 = @(y) (1 ./ (0.01 + 2 .* pi .* c .* sqrt(c.^2 * t.^2 - (y.^2)))) .* chi_B(y);
valor = integral( @(y) (K2(x-y).*(chi(y))) ,0,1/2); % Valor de la integral
end
}}

Nótese que la representación gráfica es en 2D puesto que al ser la solución radial hemos representado los puntos de la forma (x1,0) por lo que tanto la segunda coordenada como el tiempo están fijados. Además, podemos observar que dependiendo del tiempo, los valores de la solución son constantemente cero a partir de distintos puntos. Esta dependencia se debe a las funciones características, pues la característica de la solución fundamental tiene un radio que depende del tiempo a diferencia de la característica de la convolución que tiene radio fijo igual a 1/2. En definitiva, la solución será constantemente igual a cero fuera de la bola de radio ct+1/2. Excepto cuando t es igual a cero que la convolución es igual a cero ya que el integrando es igual a cero. También, cabe destacar que el pico de la solución se alcanza cuando el radio es igual a ct, pues la solución fundamental toma el mayor valor posible cuando el denominador es lo menor posible, o sea, en los puntos de radio ct.

[[Categoría:EDP]]
[[Categoría:EDP23/24]]

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T14:52:51Z

YanWang: /* Solución del problema en dimensión 2 */

{{ TrabajoEDP | Ecuación de Ondas Grupo 9 | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP23/24|2023-24]] | Miguel Cazorla Pedraza
Otelo Gallego Ayala Yan Wang}}

== Ecuación de ondas I ==

La idea principal de este artículo será dibujar diferentes soluciones de la ecuación
de ondas en una dimensión. Para ello, nos basaremos en el enunciado descrito a continuación.

=== Planteamiento del problema ===

Se considera una cuerda vibrante que ocupa el intervalo <math> [0, 1] </math> con densidad <math> d </math> y tensión
<math> \tau_0 </math> constante de manera que la velocidad de propagación es <math> c = \tau_0/d = 1 </math> . Supondremos además que la
cuerda está fija en los extremos. Llamaremos <math> u_0(x) </math> y <math> u_1(x) </math> su posición e impulso iniciales respectivamente.

Lo primero que haremos, será escribir el sistema de EDPS que modeliza el comportamiento de los desplazamiento transversales de la cuerda. Esto es:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u(0,t)=u(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=u_1(x) \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Cuya solución encontrada gracias al método de separación de las variables, el principio de superposición y las condiciones iniciales es

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}\cos(k\pi t)\right]\sin(k\pi x) </math> </center>

donde:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \sin(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \sin(k\pi x) dx</math> </center>

=== Dibujo de la solución dadas las condiciones iniciales ===
Considerando <math> u_0(x,t)= e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = 0</math>, entonces la solución tomando los primeros <math>50 </math> términos de la serie es

<center> <math> u(x,t)=\sum_{k=1}^{50} 2 \left[\int_0^1 u_0(x) \sin(k\pi x) dx\right]cos(k\pi t) \sin(k\pi x) </math> </center>

Y el dibujo de la solución en el intervalo de tiempo <math> [0,2] </math> queda así:

[[Archivo:63ot.png|600px|thumb|center|Solución ecuación de ondas]]

Observamos que en <math>t=0</math> la onda se divide en dos, que viajan hacia cada uno de los extremos espaciales. Cuando llegan a los extremos, cambian de signo y de sentido para volver a <math> x=0.5</math> y cuando se reencuentran mantienen el signo para repetir el recorrido, pero esta vez, cuando llegan a los extremos vuelven a hacerse positivas y en <math>t=2</math> se vuelve al estado inicial. Por ello, la solución para estas condiciones iniciales es periódica en el tiempo con periodo <math> T = 2 </math>.

Esto también se puede apreciar si repetimos el dibujo en el intervalo temporal <math> [0,4] </math>:

[[Archivo:63ot4.png|600px|thumb|center|Solución ecuación de ondas]]

==== Código ====

=== Otros datos iniciales más particulares para el sistema ===
Ahora, consideraremos los datos iniciales correspondientes a una onda que viaja en un sólo sentido <math>\left(u(x,t) = f(x-t)\right) </math>. Para ello, tomamos:

<center> <math> u_0(x) = f(x), \hspace{3mm} u_1(x) = -f'(x) \hspace{2mm} con \hspace{2mm} f(x) = e^{-100(x-1/2)^2} </math> </center>

Es decir, la misma <math>u_0 </math> que antes pero esta vez tomamos como <math>u_1 </math> su derivada respecto el espacio cambiada de signo:

<center> <math> u_0(x) = e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = (200x-100)e^{-100(x-1/2)^2} \hspace{2mm} </math> </center>

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]\sin(k\pi x) </math> </center>

[[Archivo:64ot.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Podemos observar que claramente en el dibujo se muestra una onda que viaja en un solo sentido con longitud de onda <math>\lambda = 2 </math> metros. Por tanto la velocidad es <math>c = \frac{\lambda}{T} = \frac{2}{2} = 1 m/s </math>

La onda parte de <math>x = 0.5 </math>m y se dirige hacia <math>x=1 </math>. En <math>t = 0.5 </math>s llega a esa frontera y allí cambia de signo y de dirección, para dirigirse hacia el extremo <math>x=0</math>, que tarda en alcanzar <math>1 </math>s. Por último, cuando llega a este extremo, pasa de nuevo a tomar valores positivos y toma la dirección inicial para volver a la posición de partida <math>x = 0.5 </math>. De nuevo probando. que el periodo es de <math>2 </math> segundos.

Todo esto se ve mejor observando la onda desde otro ángulo:

[[Archivo:64ot2.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Y además hemos creado un GIF para visualizar la onda respecto al tiempo:

[[Archivo:Ejercicio41.gif|400px|thumb|center|Onda que viaja en un solo sentido]]

==== Código ====

{{matlab|codigo=
clear all
close all

% Resumen: la idea del programa es crear una matriz de pares (tiempo,
% espacio) y en cada uno de esos puntos calcular la aproximación de la
% solución mediante un bucle for que realiza la suma de términos de la serie
% calculada

% Creamos la malla en la que introduciremos las evaluaciones
evaluaciones2 = zeros(1000,100);

% Límite temporal y vectores de tiempos y espacios
T = 2;
t = linspace(0,T,100);
x = linspace(0,1,100);
tp = linspace(0,10,1000);

% Función de la condicion inicial
cond0 =@(y) exp(-100*((y-(1/2)).^2));
cond1 = @(y) 200.*(y-(1/2)).*exp(-100*((y-(1/2)).^2));

% Imponemos la condicion inicial
evaluaciones2(1,:) = cond0(x)';

% En el siguiente bucle for, para cada k calculamos el coeficiente de
% Fourier y sumamos el correspondiente término de la serie en cada punto de
% la malla. Para el cálculo de la integral que nos da el coeficiente de
% Fourier usamos la regla del trapecio con 1000 puntos en [0,1]
for k=1:100
% Puntos
N=1000;
% Extremos del intervalo
a=0; b=1;
h=(b-a)/N;
% Partición del intervalo
u=a:h:b;
% f es la funcion que queremos integrar
f0 = (cond0(u).*sin(k.*pi.*u))';
f1 = (cond1(u).*sin(k.*pi.*u))';
% Vector de pesos
w=ones(N+1,1);
w(1)=1/2; w(N+1)=1/2;
% m es el valor de la integral
m0 = h*w'*f0;
m1 = h*w'*f1;
% Calculo final de los coeficientes del seno
coef0 = 2*m0;
coef1 = 2*m1;
% Sumamos los 100 primeros términos de la serie en cada punto de la
% malla con los nuevos coeficientes
for j =1:99
for i = 2:1000
evaluaciones2(i,j) = evaluaciones2(i,j) + coef0.*sin(k.*pi.*(x(j))).*cos(k.*pi.*(tp(i))) + ...
(1/(k*pi)).*coef1.*sin(k.*pi.*(x(j))).*sin(k.*pi.*(tp(i)));
end
end
end

% Crear la animación y guardarla como GIF
% Nombre del archivo GIF
filename = 'Ejercicio4.gif';

% Configuración de la animación
fps = 5; % Fotogramas por segundo
delayTime = 1 / fps; % Tiempo de retraso entre fotogramas

for i = 1:10:1000 % Reducir el número de fotogramas
figure(1);
plot(x,evaluaciones2(i,:))
axis([0 1 -1.2 1.2])
xlabel("Espacio")
ylabel("u(x,t)")
title("t = " + mat2str(tp(i)))

% Guardar cada frame como imagen en formato GIF
frame = getframe(gcf);
im = frame2im(frame);
[imind,cm] = rgb2ind(im,64); % Reducir el número de colores

% Escribir en el archivo GIF
if i == 1
imwrite(imind,cm,filename,'gif', 'Loopcount',inf, 'DelayTime', delayTime);
else
imwrite(imind,cm,filename,'gif','WriteMode','append', 'DelayTime', delayTime);
end
end

}}

=== Diferencia con la condición Neumann ===
Por último, veremos qué ocurre si repetimos lo anterior cambiando las condiciones Dirichlet por Neumann:

<center> <math> u_x(0,t) = u_x(1,t) = 0 </math> </center>

Con ello, el sistema pasa a ser:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u_x(0,t)=u_x(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=e^{-100(x-1/2)^2}, \hspace{3mm} u_t(x,0)=(200x-100)e^{-100(x-1/2)^2} \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Aplicamos de nuevo separación de las variables y el principio de superposición peor debido al cambio en las condiciones obtenemos esta solución:

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]cos(k\pi x) </math> </center>

donde, ahora:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \cos(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \cos(k\pi x) dx</math> </center>

En este caso, la gráfica de la solución queda así:

[[Archivo:65ot.png|600px|thumb|center|Solución ecuación de ondas]]

En este caso, la velocidad de la onda es la misma y el desplazamiento ocurre en el mismo sentido y dirección. Lo único que cambia es que cuando la onda llega a los extremos del intervalo espacial, en vez de cambiar de signo, aumenta hasta el máximo y regresa al mismo valor con el cambio de dirección. Esto hace que en los extremos se cumpla la condición Neumann que hemos impuesto.

==== Código ====

== Ecuación de ondas II ==

En este apartado dibujaremos la solución fundamental de la ecuación de ondas en dimensiones 1, 2 y 3, lo que nos servirá para interpretar el principio de Huygens.

La solución fundamental es la solución que se obtiene al dar un impulso inicial muy localizado en <math> x=0 </math>. Matemáticamente resuelve el sistema
<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^n, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=\delta (x) \hspace{6mm} x\in \mathbb{R}^n . \\

\end{array}
\right. </math> </center>

Donde <math> \delta (x) </math> es la delta de Dirac. Formalmente, se define como el siguiente límite

<center> <math> \delta (x) = \lim_{r\to 0} \frac{1}{|B(0,r)|}\chi_{B(0,r)}(x) \sim \left\{
\begin{array}{ll}

\infty \hspace{4mm} x=0,\\

0 \hspace{4mm} x\neq 0,\\

\end{array}
\right. </math> </center>

Donde <math> \chi_{B(0,r)}(x) </math> es la función característica de la bola centrada en <math> 0 </math> de radio <math> r </math> y <math> |B(0,r)| </math> es el volumen de la bola.

Su expresión es:

1. En dimensión <math> n=1 </math>:

<center> <math> K_1(x,t)=\frac{1}{2c}[H(x+ct)-H(x-ct)], </math> </center>

Donde <math> H(s)= \left\{
\begin{array}{ll}

0 \hspace{4mm} si \hspace{2mm}s<0,\\

1 \hspace{4mm} si \hspace{2mm} s\geq 0,\\

\end{array}
\right.</math> es la función de Heaviside.

2. En dimensión <math> n=2 </math>:

<center> <math> K_2(x,t)=\frac{1}{2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

donde <math> \chi_{B(0,ct)}(x), </math> es la función característica de la bola de centro 0 y radio <math> ct </math>.

3. En dimensión <math> n=3 </math>:

<center> <math> K_3(x,t)=\frac{\delta (|x|-ct)}{4\pi c |x| }, \hspace{2mm} t>0. </math> </center>

=== Representaciones ===

Antes de nada, nótese que la solución fundamental es radial para todas estas dimensiones. La primera lo es puesto que <math> x\in \mathbb{R}</math>, y las otras dos son radiales porque la variable espacial <math> x </math> aparece siempre en módulo, <math> |x| </math>.

A continuación, dibujamos las dichas soluciones fundamentales:

[[Archivo:Pr471.png|600px|thumb|right|Solución estacionaria]]

{{matlab|codigo=
% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función de Heaviside
H = @(s) double(s >= 0);

% Definir la función K1(x,t)
K1 = @(x, t) (1 / (2 * c)) * (H(x + c * t) - H(x - c * t));

% Rango de valores para x y t
x = linspace(-10, 10, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 10, 1000); % Ajusta el rango y la resolución según lo necesites

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K1 para cada par de valores (x, t)
K1_values = arrayfun(@(x_val, t_val) K1(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K1_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_1(x,t)');
title(['Gráfico de K_1(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

Como podemos ver en la expresión analítica, esta función fundamental tiene una singularidad cuando <math> c^2t^2=|x|^2 </math>. Por ello, para poder representarla añadiremos un sumando <math> \epsilon </math> al denominador, esto es

<center> <math> K_2(x,t)=\frac{1}{\epsilon +2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

Su representación gráfica en función de la variable radial es la dada por la siguiente imagen:

[[Archivo:Pr472.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función característica de la bola de centro 0 y radio ct
chi_B = @(x, t) double(abs(x) <= c * t);

% Definir la función K2(x,t)
K2 = @(x, t) (1 ./ (0.01 + 2 * pi * c * sqrt(c^2 * t.^2 - x.^2))) .* chi_B(x, t);

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K2 para cada par de valores (x, t)
K2_values = arrayfun(@(x_val, t_val) K2(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K2_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_2(x,t)');
title(['Gráfico de K_2(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad

}}

En dimensión <math> n=3 </math>, para poder hacer la representación tendremos que tomar la siguiente aproximación de la delta de Dirac:

<center> <math> \delta(s) \sim \phi _k (s) = \sqrt{\frac{1000}{\pi}e^{-1000s^2}} </math> </center>

Así, su representación queda como sigue:

[[Archivo:pr473.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites
a = 1000; % Constante del exponente

% Definir la función K3(x,t)
K3 = @(x, t) (sqrt((a / pi) * exp(-a * (abs(x) - c * t).^2))) ./ (4 * pi * c * abs(x));

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K3 para cada par de valores (x, t)
K3_values = arrayfun(@(x_val, t_val) K3(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K3_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_3(x,t)');
title(['Gráfico de K_3(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

=== Solución del problema en dimensión 2 ===

La solución del problema:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^2, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)= h(x) = \chi_{B(0,1/2)}(x)\hspace{6mm} x\in \mathbb{R}^2 . \\

\end{array}
\right. </math> </center>

viene dada por la convolución:

<center> <math>u(x,t) = \int_{\mathbb{R}^2} K_2(x-y,t)h(y) dy</math> </center>

Aprovecharemos que la solución es radial para calcularla sólo en los puntos de la forma <math>(x_1,0)</math> con <math>x_1 > 0</math>.

A continuación se muestran los dibujos de las soluciones para <math> t =0, 0.5, 1, 2</math>

[[Archivo:FundamemtalConv.jpg|600px|thumb|center|Solución a partir de la convolución]]

{{matlab|codigo=

t = [0;0.5;1;2]; % Vector de tiempos donde evaluamos la solución
x = linspace(0,3,100); % Vector de discretización del espacio
sols = zeros(length(t),length(x)); % Matriz de valores de la solución en la discretización en los diferentes tiempos

% Cálculo de valores de la solución y representación gráfica
figure(1)
for j=1:length(t)
for i = 1:length(x)
sols(j,i) = g(x(i),t(j));
end
subplot(2,2,j)
plot(x,sols(j,:))
title("Solución para t =" + num2str(t(j)))
xlabel('x1')
ylabel('u((x1,0),t)')
end

% Función que devuelve los valores de la solución por convolución
function valor = g(x,t)
% Definir la función característica de la bola de centro 0 y radio ct
c = 1;
chi_B = @(y) double(abs(y) <= c .* t); % Función característica en la bola de centro 0 y radio ct
chi = @(y) double(abs(y) <= 1/2); % Función característica en la bola de centro 0 y radio 1/2
% Definir la función K2(x,t)
K2 = @(y) (1 ./ (0.01 + 2 .* pi .* c .* sqrt(c.^2 * t.^2 - (y.^2)))) .* chi_B(y);
valor = integral( @(y) (K2(x-y).*(chi(y))) ,0,1/2); % Valor de la integral
end
}}

Nótese que la representación gráfica es en 2D puesto que al ser la solución radial hemos representado los puntos de la forma (x1,0) por lo que tanto la segunda coordenada como el tiempo están fijados. Además, podemos observar que dependiendo del tiempo, los valores de la solución es constantemente cero. Esta dependencia se debe a las funciones características, pues la característica de la solución fundamental tiene un radio que depende del tiempo a diferencia de la característica de la convolución tiene radio fijo igual a 1/2. En definitiva, la solución será constantemente igual a cero fuera de la bola de radio ct+1/2.

[[Categoría:EDP]]
[[Categoría:EDP23/24]]

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T14:35:27Z

YanWang: /* Solución del problema en dimensión 2 */

{{ TrabajoEDP | Ecuación de Ondas Grupo 9 | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP23/24|2023-24]] | Miguel Cazorla Pedraza
Otelo Gallego Ayala Yan Wang}}

== Ecuación de ondas I ==

La idea principal de este artículo será dibujar diferentes soluciones de la ecuación
de ondas en una dimensión. Para ello, nos basaremos en el enunciado descrito a continuación.

=== Planteamiento del problema ===

Se considera una cuerda vibrante que ocupa el intervalo <math> [0, 1] </math> con densidad <math> d </math> y tensión
<math> \tau_0 </math> constante de manera que la velocidad de propagación es <math> c = \tau_0/d = 1 </math> . Supondremos además que la
cuerda está fija en los extremos. Llamaremos <math> u_0(x) </math> y <math> u_1(x) </math> su posición e impulso iniciales respectivamente.

Lo primero que haremos, será escribir el sistema de EDPS que modeliza el comportamiento de los desplazamiento transversales de la cuerda. Esto es:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u(0,t)=u(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=u_1(x) \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Cuya solución encontrada gracias al método de separación de las variables, el principio de superposición y las condiciones iniciales es

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}\cos(k\pi t)\right]\sin(k\pi x) </math> </center>

donde:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \sin(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \sin(k\pi x) dx</math> </center>

=== Dibujo de la solución dadas las condiciones iniciales ===
Considerando <math> u_0(x,t)= e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = 0</math>, entonces la solución tomando los primeros <math>50 </math> términos de la serie es

<center> <math> u(x,t)=\sum_{k=1}^{50} 2 \left[\int_0^1 u_0(x) \sin(k\pi x) dx\right]cos(k\pi t) \sin(k\pi x) </math> </center>

Y el dibujo de la solución en el intervalo de tiempo <math> [0,2] </math> queda así:

[[Archivo:63ot.png|600px|thumb|center|Solución ecuación de ondas]]

Observamos que en <math>t=0</math> la onda se divide en dos, que viajan hacia cada uno de los extremos espaciales. Cuando llegan a los extremos, cambian de signo y de sentido para volver a <math> x=0.5</math> y cuando se reencuentran mantienen el signo para repetir el recorrido, pero esta vez, cuando llegan a los extremos vuelven a hacerse positivas y en <math>t=2</math> se vuelve al estado inicial. Por ello, la solución para estas condiciones iniciales es periódica en el tiempo con periodo <math> T = 2 </math>.

Esto también se puede apreciar si repetimos el dibujo en el intervalo temporal <math> [0,4] </math>:

[[Archivo:63ot4.png|600px|thumb|center|Solución ecuación de ondas]]

==== Código ====

=== Otros datos iniciales más particulares para el sistema ===
Ahora, consideraremos los datos iniciales correspondientes a una onda que viaja en un sólo sentido <math>\left(u(x,t) = f(x-t)\right) </math>. Para ello, tomamos:

<center> <math> u_0(x) = f(x), \hspace{3mm} u_1(x) = -f'(x) \hspace{2mm} con \hspace{2mm} f(x) = e^{-100(x-1/2)^2} </math> </center>

Es decir, la misma <math>u_0 </math> que antes pero esta vez tomamos como <math>u_1 </math> su derivada respecto el espacio cambiada de signo:

<center> <math> u_0(x) = e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = (200x-100)e^{-100(x-1/2)^2} \hspace{2mm} </math> </center>

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]\sin(k\pi x) </math> </center>

[[Archivo:64ot.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Podemos observar que claramente en el dibujo se muestra una onda que viaja en un solo sentido con longitud de onda <math>\lambda = 2 </math> metros. Por tanto la velocidad es <math>c = \frac{\lambda}{T} = \frac{2}{2} = 1 m/s </math>

La onda parte de <math>x = 0.5 </math>m y se dirige hacia <math>x=1 </math>. En <math>t = 0.5 </math>s llega a esa frontera y allí cambia de signo y de dirección, para dirigirse hacia el extremo <math>x=0</math>, que tarda en alcanzar <math>1 </math>s. Por último, cuando llega a este extremo, pasa de nuevo a tomar valores positivos y toma la dirección inicial para volver a la posición de partida <math>x = 0.5 </math>. De nuevo probando. que el periodo es de <math>2 </math> segundos.

Todo esto se ve mejor observando la onda desde otro ángulo:

[[Archivo:64ot2.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Y además hemos creado un GIF para visualizar la onda respecto al tiempo:

[[Archivo:Ejercicio41.gif|400px|thumb|center|Onda que viaja en un solo sentido]]

==== Código ====

{{matlab|codigo=
clear all
close all

% Resumen: la idea del programa es crear una matriz de pares (tiempo,
% espacio) y en cada uno de esos puntos calcular la aproximación de la
% solución mediante un bucle for que realiza la suma de términos de la serie
% calculada

% Creamos la malla en la que introduciremos las evaluaciones
evaluaciones2 = zeros(1000,100);

% Límite temporal y vectores de tiempos y espacios
T = 2;
t = linspace(0,T,100);
x = linspace(0,1,100);
tp = linspace(0,10,1000);

% Función de la condicion inicial
cond0 =@(y) exp(-100*((y-(1/2)).^2));
cond1 = @(y) 200.*(y-(1/2)).*exp(-100*((y-(1/2)).^2));

% Imponemos la condicion inicial
evaluaciones2(1,:) = cond0(x)';

% En el siguiente bucle for, para cada k calculamos el coeficiente de
% Fourier y sumamos el correspondiente término de la serie en cada punto de
% la malla. Para el cálculo de la integral que nos da el coeficiente de
% Fourier usamos la regla del trapecio con 1000 puntos en [0,1]
for k=1:100
% Puntos
N=1000;
% Extremos del intervalo
a=0; b=1;
h=(b-a)/N;
% Partición del intervalo
u=a:h:b;
% f es la funcion que queremos integrar
f0 = (cond0(u).*sin(k.*pi.*u))';
f1 = (cond1(u).*sin(k.*pi.*u))';
% Vector de pesos
w=ones(N+1,1);
w(1)=1/2; w(N+1)=1/2;
% m es el valor de la integral
m0 = h*w'*f0;
m1 = h*w'*f1;
% Calculo final de los coeficientes del seno
coef0 = 2*m0;
coef1 = 2*m1;
% Sumamos los 100 primeros términos de la serie en cada punto de la
% malla con los nuevos coeficientes
for j =1:99
for i = 2:1000
evaluaciones2(i,j) = evaluaciones2(i,j) + coef0.*sin(k.*pi.*(x(j))).*cos(k.*pi.*(tp(i))) + ...
(1/(k*pi)).*coef1.*sin(k.*pi.*(x(j))).*sin(k.*pi.*(tp(i)));
end
end
end

% Crear la animación y guardarla como GIF
% Nombre del archivo GIF
filename = 'Ejercicio4.gif';

% Configuración de la animación
fps = 5; % Fotogramas por segundo
delayTime = 1 / fps; % Tiempo de retraso entre fotogramas

for i = 1:10:1000 % Reducir el número de fotogramas
figure(1);
plot(x,evaluaciones2(i,:))
axis([0 1 -1.2 1.2])
xlabel("Espacio")
ylabel("u(x,t)")
title("t = " + mat2str(tp(i)))

% Guardar cada frame como imagen en formato GIF
frame = getframe(gcf);
im = frame2im(frame);
[imind,cm] = rgb2ind(im,64); % Reducir el número de colores

% Escribir en el archivo GIF
if i == 1
imwrite(imind,cm,filename,'gif', 'Loopcount',inf, 'DelayTime', delayTime);
else
imwrite(imind,cm,filename,'gif','WriteMode','append', 'DelayTime', delayTime);
end
end

}}

=== Diferencia con la condición Neumann ===
Por último, veremos qué ocurre si repetimos lo anterior cambiando las condiciones Dirichlet por Neumann:

<center> <math> u_x(0,t) = u_x(1,t) = 0 </math> </center>

Con ello, el sistema pasa a ser:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u_x(0,t)=u_x(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=e^{-100(x-1/2)^2}, \hspace{3mm} u_t(x,0)=(200x-100)e^{-100(x-1/2)^2} \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Aplicamos de nuevo separación de las variables y el principio de superposición peor debido al cambio en las condiciones obtenemos esta solución:

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]cos(k\pi x) </math> </center>

donde, ahora:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \cos(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \cos(k\pi x) dx</math> </center>

En este caso, la gráfica de la solución queda así:

[[Archivo:65ot.png|600px|thumb|center|Solución ecuación de ondas]]

En este caso, la velocidad de la onda es la misma y el desplazamiento ocurre en el mismo sentido y dirección. Lo único que cambia es que cuando la onda llega a los extremos del intervalo espacial, en vez de cambiar de signo, aumenta hasta el máximo y regresa al mismo valor con el cambio de dirección. Esto hace que en los extremos se cumpla la condición Neumann que hemos impuesto.

==== Código ====

== Ecuación de ondas II ==

En este apartado dibujaremos la solución fundamental de la ecuación de ondas en dimensiones 1, 2 y 3, lo que nos servirá para interpretar el principio de Huygens.

La solución fundamental es la solución que se obtiene al dar un impulso inicial muy localizado en <math> x=0 </math>. Matemáticamente resuelve el sistema
<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^n, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=\delta (x) \hspace{6mm} x\in \mathbb{R}^n . \\

\end{array}
\right. </math> </center>

Donde <math> \delta (x) </math> es la delta de Dirac. Formalmente, se define como el siguiente límite

<center> <math> \delta (x) = \lim_{r\to 0} \frac{1}{|B(0,r)|}\chi_{B(0,r)}(x) \sim \left\{
\begin{array}{ll}

\infty \hspace{4mm} x=0,\\

0 \hspace{4mm} x\neq 0,\\

\end{array}
\right. </math> </center>

Donde <math> \chi_{B(0,r)}(x) </math> es la función característica de la bola centrada en <math> 0 </math> de radio <math> r </math> y <math> |B(0,r)| </math> es el volumen de la bola.

Su expresión es:

1. En dimensión <math> n=1 </math>:

<center> <math> K_1(x,t)=\frac{1}{2c}[H(x+ct)-H(x-ct)], </math> </center>

Donde <math> H(s)= \left\{
\begin{array}{ll}

0 \hspace{4mm} si \hspace{2mm}s<0,\\

1 \hspace{4mm} si \hspace{2mm} s\geq 0,\\

\end{array}
\right.</math> es la función de Heaviside.

2. En dimensión <math> n=2 </math>:

<center> <math> K_2(x,t)=\frac{1}{2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

donde <math> \chi_{B(0,ct)}(x), </math> es la función característica de la bola de centro 0 y radio <math> ct </math>.

3. En dimensión <math> n=3 </math>:

<center> <math> K_3(x,t)=\frac{\delta (|x|-ct)}{4\pi c |x| }, \hspace{2mm} t>0. </math> </center>

=== Representaciones ===

Antes de nada, nótese que la solución fundamental es radial para todas estas dimensiones. La primera lo es puesto que <math> x\in \mathbb{R}</math>, y las otras dos son radiales porque la variable espacial <math> x </math> aparece siempre en módulo, <math> |x| </math>.

A continuación, dibujamos las dichas soluciones fundamentales:

[[Archivo:Pr471.png|600px|thumb|right|Solución estacionaria]]

{{matlab|codigo=
% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función de Heaviside
H = @(s) double(s >= 0);

% Definir la función K1(x,t)
K1 = @(x, t) (1 / (2 * c)) * (H(x + c * t) - H(x - c * t));

% Rango de valores para x y t
x = linspace(-10, 10, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 10, 1000); % Ajusta el rango y la resolución según lo necesites

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K1 para cada par de valores (x, t)
K1_values = arrayfun(@(x_val, t_val) K1(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K1_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_1(x,t)');
title(['Gráfico de K_1(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

Como podemos ver en la expresión analítica, esta función fundamental tiene una singularidad cuando <math> c^2t^2=|x|^2 </math>. Por ello, para poder representarla añadiremos un sumando <math> \epsilon </math> al denominador, esto es

<center> <math> K_2(x,t)=\frac{1}{\epsilon +2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

Su representación gráfica en función de la variable radial es la dada por la siguiente imagen:

[[Archivo:Pr472.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función característica de la bola de centro 0 y radio ct
chi_B = @(x, t) double(abs(x) <= c * t);

% Definir la función K2(x,t)
K2 = @(x, t) (1 ./ (0.01 + 2 * pi * c * sqrt(c^2 * t.^2 - x.^2))) .* chi_B(x, t);

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K2 para cada par de valores (x, t)
K2_values = arrayfun(@(x_val, t_val) K2(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K2_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_2(x,t)');
title(['Gráfico de K_2(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad

}}

En dimensión <math> n=3 </math>, para poder hacer la representación tendremos que tomar la siguiente aproximación de la delta de Dirac:

<center> <math> \delta(s) \sim \phi _k (s) = \sqrt{\frac{1000}{\pi}e^{-1000s^2}} </math> </center>

Así, su representación queda como sigue:

[[Archivo:pr473.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites
a = 1000; % Constante del exponente

% Definir la función K3(x,t)
K3 = @(x, t) (sqrt((a / pi) * exp(-a * (abs(x) - c * t).^2))) ./ (4 * pi * c * abs(x));

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K3 para cada par de valores (x, t)
K3_values = arrayfun(@(x_val, t_val) K3(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K3_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_3(x,t)');
title(['Gráfico de K_3(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

=== Solución del problema en dimensión 2 ===

La solución del problema:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^2, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)= h(x) = \chi_{B(0,1/2)}(x)\hspace{6mm} x\in \mathbb{R}^2 . \\

\end{array}
\right. </math> </center>

viene dada por la convolución:

<center> <math>u(x,t) = \int_{\mathbb{R}^2} K_2(x-y,t)h(y) dy</math> </center>

Aprovecharemos que la solución es radial para calcularla sólo en los puntos de la forma <math>(x_1,0)</math> con <math>x_1 > 0</math>.

A continuación se muestran los dibujos de las soluciones para <math> t =0, 0.5, 1, 2</math>

[[Archivo:FundamemtalConv.jpg|600px|thumb|center|Solución a partir de la convolución]]

{{matlab|codigo=

t = [0;0.5;1;2]; % Vector de tiempos donde evaluamos la solución
x = linspace(0,3,100); % Vector de discretización del espacio
sols = zeros(length(t),length(x)); % Matriz de valores de la solución en la discretización en los diferentes tiempos

% Cálculo de valores de la solución y representación gráfica
figure(1)
for j=1:length(t)
for i = 1:length(x)
sols(j,i) = g(x(i),t(j));
end
subplot(2,2,j)
plot(x,sols(j,:))
title("Solución para t =" + num2str(t(j)))
xlabel('x1')
ylabel('u((x1,0),t)')
end

% Función que devuelve los valores de la solución por convolución
function valor = g(x,t)
% Definir la función característica de la bola de centro 0 y radio ct
c = 1;
chi_B = @(y) double(abs(y) <= c .* t); % Función característica en la bola de centro 0 y radio ct
chi = @(y) double(abs(y) <= 1/2); % Función característica en la bola de centro 0 y radio 1/2
% Definir la función K2(x,t)
K2 = @(y) (1 ./ (0.01 + 2 .* pi .* c .* sqrt(c.^2 * t.^2 - (y.^2)))) .* chi_B(y);
valor = integral( @(y) (K2(x-y).*(chi(y))) ,0,1/2); % Valor de la integral
end
}}

[[Categoría:EDP]]
[[Categoría:EDP23/24]]

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T14:33:52Z

YanWang: /* Solución del problema en dimensión 2 */

{{ TrabajoEDP | Ecuación de Ondas Grupo 9 | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP23/24|2023-24]] | Miguel Cazorla Pedraza
Otelo Gallego Ayala Yan Wang}}

== Ecuación de ondas I ==

La idea principal de este artículo será dibujar diferentes soluciones de la ecuación
de ondas en una dimensión. Para ello, nos basaremos en el enunciado descrito a continuación.

=== Planteamiento del problema ===

Se considera una cuerda vibrante que ocupa el intervalo <math> [0, 1] </math> con densidad <math> d </math> y tensión
<math> \tau_0 </math> constante de manera que la velocidad de propagación es <math> c = \tau_0/d = 1 </math> . Supondremos además que la
cuerda está fija en los extremos. Llamaremos <math> u_0(x) </math> y <math> u_1(x) </math> su posición e impulso iniciales respectivamente.

Lo primero que haremos, será escribir el sistema de EDPS que modeliza el comportamiento de los desplazamiento transversales de la cuerda. Esto es:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u(0,t)=u(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=u_1(x) \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Cuya solución encontrada gracias al método de separación de las variables, el principio de superposición y las condiciones iniciales es

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}\cos(k\pi t)\right]\sin(k\pi x) </math> </center>

donde:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \sin(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \sin(k\pi x) dx</math> </center>

=== Dibujo de la solución dadas las condiciones iniciales ===
Considerando <math> u_0(x,t)= e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = 0</math>, entonces la solución tomando los primeros <math>50 </math> términos de la serie es

<center> <math> u(x,t)=\sum_{k=1}^{50} 2 \left[\int_0^1 u_0(x) \sin(k\pi x) dx\right]cos(k\pi t) \sin(k\pi x) </math> </center>

Y el dibujo de la solución en el intervalo de tiempo <math> [0,2] </math> queda así:

[[Archivo:63ot.png|600px|thumb|center|Solución ecuación de ondas]]

Observamos que en <math>t=0</math> la onda se divide en dos, que viajan hacia cada uno de los extremos espaciales. Cuando llegan a los extremos, cambian de signo y de sentido para volver a <math> x=0.5</math> y cuando se reencuentran mantienen el signo para repetir el recorrido, pero esta vez, cuando llegan a los extremos vuelven a hacerse positivas y en <math>t=2</math> se vuelve al estado inicial. Por ello, la solución para estas condiciones iniciales es periódica en el tiempo con periodo <math> T = 2 </math>.

Esto también se puede apreciar si repetimos el dibujo en el intervalo temporal <math> [0,4] </math>:

[[Archivo:63ot4.png|600px|thumb|center|Solución ecuación de ondas]]

==== Código ====

=== Otros datos iniciales más particulares para el sistema ===
Ahora, consideraremos los datos iniciales correspondientes a una onda que viaja en un sólo sentido <math>\left(u(x,t) = f(x-t)\right) </math>. Para ello, tomamos:

<center> <math> u_0(x) = f(x), \hspace{3mm} u_1(x) = -f'(x) \hspace{2mm} con \hspace{2mm} f(x) = e^{-100(x-1/2)^2} </math> </center>

Es decir, la misma <math>u_0 </math> que antes pero esta vez tomamos como <math>u_1 </math> su derivada respecto el espacio cambiada de signo:

<center> <math> u_0(x) = e^{-100(x-1/2)^2}, \hspace{3mm} u_1(x) = (200x-100)e^{-100(x-1/2)^2} \hspace{2mm} </math> </center>

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]\sin(k\pi x) </math> </center>

[[Archivo:64ot.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Podemos observar que claramente en el dibujo se muestra una onda que viaja en un solo sentido con longitud de onda <math>\lambda = 2 </math> metros. Por tanto la velocidad es <math>c = \frac{\lambda}{T} = \frac{2}{2} = 1 m/s </math>

La onda parte de <math>x = 0.5 </math>m y se dirige hacia <math>x=1 </math>. En <math>t = 0.5 </math>s llega a esa frontera y allí cambia de signo y de dirección, para dirigirse hacia el extremo <math>x=0</math>, que tarda en alcanzar <math>1 </math>s. Por último, cuando llega a este extremo, pasa de nuevo a tomar valores positivos y toma la dirección inicial para volver a la posición de partida <math>x = 0.5 </math>. De nuevo probando. que el periodo es de <math>2 </math> segundos.

Todo esto se ve mejor observando la onda desde otro ángulo:

[[Archivo:64ot2.png|600px|thumb|center|Onda que viaja en un solo sentido]]

Y además hemos creado un GIF para visualizar la onda respecto al tiempo:

[[Archivo:Ejercicio41.gif|400px|thumb|center|Onda que viaja en un solo sentido]]

==== Código ====

{{matlab|codigo=
clear all
close all

% Resumen: la idea del programa es crear una matriz de pares (tiempo,
% espacio) y en cada uno de esos puntos calcular la aproximación de la
% solución mediante un bucle for que realiza la suma de términos de la serie
% calculada

% Creamos la malla en la que introduciremos las evaluaciones
evaluaciones2 = zeros(1000,100);

% Límite temporal y vectores de tiempos y espacios
T = 2;
t = linspace(0,T,100);
x = linspace(0,1,100);
tp = linspace(0,10,1000);

% Función de la condicion inicial
cond0 =@(y) exp(-100*((y-(1/2)).^2));
cond1 = @(y) 200.*(y-(1/2)).*exp(-100*((y-(1/2)).^2));

% Imponemos la condicion inicial
evaluaciones2(1,:) = cond0(x)';

% En el siguiente bucle for, para cada k calculamos el coeficiente de
% Fourier y sumamos el correspondiente término de la serie en cada punto de
% la malla. Para el cálculo de la integral que nos da el coeficiente de
% Fourier usamos la regla del trapecio con 1000 puntos en [0,1]
for k=1:100
% Puntos
N=1000;
% Extremos del intervalo
a=0; b=1;
h=(b-a)/N;
% Partición del intervalo
u=a:h:b;
% f es la funcion que queremos integrar
f0 = (cond0(u).*sin(k.*pi.*u))';
f1 = (cond1(u).*sin(k.*pi.*u))';
% Vector de pesos
w=ones(N+1,1);
w(1)=1/2; w(N+1)=1/2;
% m es el valor de la integral
m0 = h*w'*f0;
m1 = h*w'*f1;
% Calculo final de los coeficientes del seno
coef0 = 2*m0;
coef1 = 2*m1;
% Sumamos los 100 primeros términos de la serie en cada punto de la
% malla con los nuevos coeficientes
for j =1:99
for i = 2:1000
evaluaciones2(i,j) = evaluaciones2(i,j) + coef0.*sin(k.*pi.*(x(j))).*cos(k.*pi.*(tp(i))) + ...
(1/(k*pi)).*coef1.*sin(k.*pi.*(x(j))).*sin(k.*pi.*(tp(i)));
end
end
end

% Crear la animación y guardarla como GIF
% Nombre del archivo GIF
filename = 'Ejercicio4.gif';

% Configuración de la animación
fps = 5; % Fotogramas por segundo
delayTime = 1 / fps; % Tiempo de retraso entre fotogramas

for i = 1:10:1000 % Reducir el número de fotogramas
figure(1);
plot(x,evaluaciones2(i,:))
axis([0 1 -1.2 1.2])
xlabel("Espacio")
ylabel("u(x,t)")
title("t = " + mat2str(tp(i)))

% Guardar cada frame como imagen en formato GIF
frame = getframe(gcf);
im = frame2im(frame);
[imind,cm] = rgb2ind(im,64); % Reducir el número de colores

% Escribir en el archivo GIF
if i == 1
imwrite(imind,cm,filename,'gif', 'Loopcount',inf, 'DelayTime', delayTime);
else
imwrite(imind,cm,filename,'gif','WriteMode','append', 'DelayTime', delayTime);
end
end

}}

=== Diferencia con la condición Neumann ===
Por último, veremos qué ocurre si repetimos lo anterior cambiando las condiciones Dirichlet por Neumann:

<center> <math> u_x(0,t) = u_x(1,t) = 0 </math> </center>

Con ello, el sistema pasa a ser:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-u_{xx}=0, \hspace{6mm} t> 0, x\in [0,1], \\
u_x(0,t)=u_x(1,t)=0, \hspace{6mm} t>0, \\
u(x,0)=e^{-100(x-1/2)^2}, \hspace{3mm} u_t(x,0)=(200x-100)e^{-100(x-1/2)^2} \hspace{6mm} x\in [0,1]. \\

\end{array}
\right. </math> </center>

Aplicamos de nuevo separación de las variables y el principio de superposición peor debido al cambio en las condiciones obtenemos esta solución:

<center> <math> u(x,t)=\sum_{k=1}^\infty \left[\frac{1}{k\pi}u_{1,k}\sin(k\pi t)+u_{0,k}cos(k\pi t)\right]cos(k\pi x) </math> </center>

donde, ahora:

<center> <math> u_{1,k} = 2 \int_0^1 u_1(x) \cos(k\pi x) dx </math> </center>

<center> <math> u_{0,k} = 2 \int_0^1 u_0(x) \cos(k\pi x) dx</math> </center>

En este caso, la gráfica de la solución queda así:

[[Archivo:65ot.png|600px|thumb|center|Solución ecuación de ondas]]

En este caso, la velocidad de la onda es la misma y el desplazamiento ocurre en el mismo sentido y dirección. Lo único que cambia es que cuando la onda llega a los extremos del intervalo espacial, en vez de cambiar de signo, aumenta hasta el máximo y regresa al mismo valor con el cambio de dirección. Esto hace que en los extremos se cumpla la condición Neumann que hemos impuesto.

==== Código ====

== Ecuación de ondas II ==

En este apartado dibujaremos la solución fundamental de la ecuación de ondas en dimensiones 1, 2 y 3, lo que nos servirá para interpretar el principio de Huygens.

La solución fundamental es la solución que se obtiene al dar un impulso inicial muy localizado en <math> x=0 </math>. Matemáticamente resuelve el sistema
<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^n, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)=\delta (x) \hspace{6mm} x\in \mathbb{R}^n . \\

\end{array}
\right. </math> </center>

Donde <math> \delta (x) </math> es la delta de Dirac. Formalmente, se define como el siguiente límite

<center> <math> \delta (x) = \lim_{r\to 0} \frac{1}{|B(0,r)|}\chi_{B(0,r)}(x) \sim \left\{
\begin{array}{ll}

\infty \hspace{4mm} x=0,\\

0 \hspace{4mm} x\neq 0,\\

\end{array}
\right. </math> </center>

Donde <math> \chi_{B(0,r)}(x) </math> es la función característica de la bola centrada en <math> 0 </math> de radio <math> r </math> y <math> |B(0,r)| </math> es el volumen de la bola.

Su expresión es:

1. En dimensión <math> n=1 </math>:

<center> <math> K_1(x,t)=\frac{1}{2c}[H(x+ct)-H(x-ct)], </math> </center>

Donde <math> H(s)= \left\{
\begin{array}{ll}

0 \hspace{4mm} si \hspace{2mm}s<0,\\

1 \hspace{4mm} si \hspace{2mm} s\geq 0,\\

\end{array}
\right.</math> es la función de Heaviside.

2. En dimensión <math> n=2 </math>:

<center> <math> K_2(x,t)=\frac{1}{2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

donde <math> \chi_{B(0,ct)}(x), </math> es la función característica de la bola de centro 0 y radio <math> ct </math>.

3. En dimensión <math> n=3 </math>:

<center> <math> K_3(x,t)=\frac{\delta (|x|-ct)}{4\pi c |x| }, \hspace{2mm} t>0. </math> </center>

=== Representaciones ===

Antes de nada, nótese que la solución fundamental es radial para todas estas dimensiones. La primera lo es puesto que <math> x\in \mathbb{R}</math>, y las otras dos son radiales porque la variable espacial <math> x </math> aparece siempre en módulo, <math> |x| </math>.

A continuación, dibujamos las dichas soluciones fundamentales:

[[Archivo:Pr471.png|600px|thumb|right|Solución estacionaria]]

{{matlab|codigo=
% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función de Heaviside
H = @(s) double(s >= 0);

% Definir la función K1(x,t)
K1 = @(x, t) (1 / (2 * c)) * (H(x + c * t) - H(x - c * t));

% Rango de valores para x y t
x = linspace(-10, 10, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 10, 1000); % Ajusta el rango y la resolución según lo necesites

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K1 para cada par de valores (x, t)
K1_values = arrayfun(@(x_val, t_val) K1(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K1_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_1(x,t)');
title(['Gráfico de K_1(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

Como podemos ver en la expresión analítica, esta función fundamental tiene una singularidad cuando <math> c^2t^2=|x|^2 </math>. Por ello, para poder representarla añadiremos un sumando <math> \epsilon </math> al denominador, esto es

<center> <math> K_2(x,t)=\frac{1}{\epsilon +2\pi c\sqrt{c^2t^2-|x|^2}}\chi_{B(0,ct)}(x), </math> </center>

Su representación gráfica en función de la variable radial es la dada por la siguiente imagen:

[[Archivo:Pr472.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites

% Definir la función característica de la bola de centro 0 y radio ct
chi_B = @(x, t) double(abs(x) <= c * t);

% Definir la función K2(x,t)
K2 = @(x, t) (1 ./ (0.01 + 2 * pi * c * sqrt(c^2 * t.^2 - x.^2))) .* chi_B(x, t);

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K2 para cada par de valores (x, t)
K2_values = arrayfun(@(x_val, t_val) K2(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K2_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_2(x,t)');
title(['Gráfico de K_2(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad

}}

En dimensión <math> n=3 </math>, para poder hacer la representación tendremos que tomar la siguiente aproximación de la delta de Dirac:

<center> <math> \delta(s) \sim \phi _k (s) = \sqrt{\frac{1000}{\pi}e^{-1000s^2}} </math> </center>

Así, su representación queda como sigue:

[[Archivo:pr473.png|600px|thumb|left|Solución estacionaria]]

{{matlab|codigo=

% Parámetros
c = 1; % Puedes ajustar el valor de c según lo necesites
a = 1000; % Constante del exponente

% Definir la función K3(x,t)
K3 = @(x, t) (sqrt((a / pi) * exp(-a * (abs(x) - c * t).^2))) ./ (4 * pi * c * abs(x));

% Rango de valores para x y t
x = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites
t = linspace(0, 1, 1000); % Ajusta el rango y la resolución según lo necesites, evitando t=0 para evitar división por cero

% Crear mallas para x y t
[X, T] = meshgrid(x, t);

% Calcular K3 para cada par de valores (x, t)
K3_values = arrayfun(@(x_val, t_val) K3(x_val, t_val), X, T);

% Dibujar la función
figure;
surf(X, T, K3_values, 'EdgeColor', 'none');

% Añadir más color
colormap(jet); % Utilizar el colormap 'jet' para colores más vibrantes
colorbar;
shading interp; % Interpolación de colores para suavizar la apariencia

% Añadir etiquetas y título
xlabel('x');
ylabel('t');
zlabel('K_3(x,t)');
title(['Gráfico de K_3(x,t) para c = ', num2str(c)]);

% Añadir rejilla y ajustar la vista
grid on;
view(3); % Vista en 3D

% Ajustar propiedades de la figura
set(gca, 'FontSize', 12); % Tamaño de fuente más grande para mejorar la legibilidad
}}

=== Solución del problema en dimensión 2 ===

La solución del problema:

<center> <math> \left\{
\begin{array}{ll}

u_{tt}-c^2\Delta u=0, \hspace{6mm} \hspace{32mm} x\in \mathbb{R}^2, t >0\\

u(x,0)=u_0(x), \hspace{3mm} u_t(x,0)= h(x) = \chi_{B(0,1/2)}(x)\hspace{6mm} x\in \mathbb{R}^2 . \\

\end{array}
\right. </math> </center>

viene dada por la convolución:

<center> <math>u(x,t) = \int_{\mathbb{R}^2} K_2(x-y,t)h(y) dy</math> </center>

'''SOLUCIÓN RADIAL EN X'''
Aprovecharemos que la slución es radial para calcularla sólo en los puntos de la forma <math>(x_1,0)</math> con <math>x_1 > 0</math>.

A continuación se muestran los dibujos de las soluciones para <math> t =0, 0.5, 1, 2</math>

[[Archivo:FundamemtalConv.jpg|600px|thumb|center|Solución a partir de la convolución]]

{codigo | matlab

t = [0;0.5;1;2]; % Vector de tiempos donde evaluamos la solución
x = linspace(0,3,100); % Vector de discretización del espacio
sols = zeros(length(t),length(x)); % Matriz de valores de la solución en la discretización en los diferentes tiempos

% Cálculo de valores de la solución y representación gráfica
figure(1)
for j=1:length(t)
for i = 1:length(x)
sols(j,i) = g(x(i),t(j));
end
subplot(2,2,j)
plot(x,sols(j,:))
title("Solución para t =" + num2str(t(j)))
xlabel('x1')
ylabel('u((x1,0),t)')
end

% Función que devuelve los valores de la solución por convolución
function valor = g(x,t)
% Definir la función característica de la bola de centro 0 y radio ct
c = 1;
chi_B = @(y) double(abs(y) <= c .* t); % Función característica en la bola de centro 0 y radio ct
chi = @(y) double(abs(y) <= 1/2); % Función característica en la bola de centro 0 y radio 1/2
% Definir la función K2(x,t)
K2 = @(y) (1 ./ (0.01 + 2 .* pi .* c .* sqrt(c.^2 * t.^2 - (y.^2)))) .* chi_B(y);
valor = integral( @(y) (K2(x-y).*(chi(y))) ,0,1/2); % Valor de la integral
end
}
====Código====
[[Categoría:EDP]]
[[Categoría:EDP23/24]]

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T14:29:41Z

YanWang: /* Solución del problema en dimensión 2 */

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T14:28:54Z

YanWang: /* Solución del problema en dimensión 2 */

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T14:26:19Z

YanWang: /* Solución del problema en dimensión 2 */

Archivo:FundamemtalConv.jpg

2024-05-27T14:23:48Z

YanWang:

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T10:18:31Z

YanWang: /* Otros datos iniciales más particulares para el sistema */

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T10:05:48Z

YanWang: /* Otros datos iniciales más particulares para el sistema */

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T10:05:18Z

YanWang: /* Otros datos iniciales más particulares para el sistema */

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T10:01:39Z

YanWang: /* Otros datos iniciales más particulares para el sistema */

Ecuación de ondas. Otelo, Yan y Mika

2024-05-27T10:00:42Z

YanWang: /* Otros datos iniciales más particulares para el sistema */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T19:48:05Z

YanWang: /* Código */

{{ TrabajoEDP | Ecuación de Laplace. Grupo 9 | [[:Categoría:EDP|EDP]]|[[:Categoría:EDP23/24|2023-24]] | Miguel Cazorla Pedraza
Otelo Gallego Ayala
Yan Wang}}

== Introducción ==
En este articulo estudiaremos la ecuación de Laplace en la bola unidad de dimensión dos con diferentes condiciones frontera. En concreto, analizaremos la fórmula de Poisson y los errores cometidos al aproximar la integral de esta mediante la regla del trapecio con varias discretizaciones del dominio. Además, estudiaremos el error cometido al fijar una discretización e ir tomando puntos que se acercan a la frontera. También estudiaremos la solución por serie de Fourier y la desigualdad de Harnack para bolas de distintos radios y en dimensión 3. Por último, aproximaremos la solución de la Ecuación de Poisson con el potencial logarítmico.

== Solución de la Ecuación de Laplace con la fórmula de Poisson y la regla del trapecio ==

Consideramos el problema

<center><math> \left\{\Delta u =0, \hspace{5mm} x \in B_1\atop \hspace{5mm} u = g \hspace{5mm} x\in\partial B_1 \right. </math> </center>

donde g es la función de una variable <math> g(\theta) = \max\{0, 1-\frac{2}{\pi}|\theta - \pi|\} </math>

Como la función está en polares, para hallar la solución del problema vamos a usar la fórmula de Poisson en polares:

<center><math> u(r, \theta) = \frac{R^2 - r^2}{2\pi} \int_{0}^{2\pi}\frac{G(\varphi)}{R^2 + r^2 - 2Rr\cos(\theta - \varphi)}d\varphi</math> </center>

Para resolver numéricamente la integral de la fórmula en MatLab usaremos la regla del trapecio. Esta regla consiste en dividir <math> [0,2\pi] </math> en N subintervalos para después realizar la media de los valores del integrando en los dos extremos de cada subintervalo y multiplicarla por la longtitud de estos.

Si aplicamos la fórmula sobre la adherencia de la bola obtenemos discontinuidad en la frontera. Esto se muestra en la gráfica a continuación:

[[Archivo:41ot2.png|600px|thumb|center|Solución discontinua]]

Para solucionar esto, imponemos directamente la condición frontera y aplicamos la fórmula en el interior de la bola. De esta manera, eliminamos la discontinuidad y conseguimos la siguiente gráfica:

[[Archivo:412ot.png|600px|thumb|center|Solución tras imponer la condición frontera]]

=== Código ===
{{matlab|codigo=
%Resumen de código:
%Crearemos un malla de puntos en coordenadas polares y en cada punto
%evaluaremos usando la fórmula de Poisson, realizando la integral con la
%regla del trapecio. Sin embargo, en la frontera (r=1) evaluaremos
%directamente la función g definida a continuación

%condicion frontera
g =@(x) max(0,1-(2/pi).*abs(x-pi));

%dimensión de la malla
Q = 100;

%coordenadas polares para construir la malla
R = 1;
D = linspace(0,R,Q);%radios
Z = linspace(0, 2*pi,Q);%ángulos
evaluaciones = zeros(Q,Q);%matriz malla

%para la regla del trapecio
N=1000; %número de puntos
a=0; b=2*pi; %extremos del intervalo
h=(b-a)/N; %incremento
u=a:h:b;
w=ones(N+1,1); %vector de pesos
w(1)=1/2; w(N+1)=1/2;

%imponemos la condición frontera (r = 1) evaluando en g
for j = 1:Q
evaluaciones(Q,j) = g(Z(j));
end

%fórmula de Poisson en el interior
for i =1:Q-1 %hasta Q-1 para no aplicarla en la frontera
r = D(i);
for j = 1:Q
z = Z(j).*ones(1,N+1); %tenemos que convertirlo en vector para poder operar con u
f = (g(u)./(R^2 + r^2 - (2*R*r).*cos(z - u)))'; %funcion que integramos
int = h*w'*f; %resultado de la integral
evaluaciones(i,j) = ((R^2 - r^2)/(2*pi))*int; %formula de poisson en coordenadas polares
end
end

%pasamos a cartesianas para hacer la gráfica
X = D'*cos(Z);
Y = D'*sin(Z);

%representación 3D
surf(X,Y,evaluaciones)
title('Imponiendo la condición frontera')
xlabel('X')
ylabel('Y')
zlabel('u')
}}

== Limitaciones de la fórmula de Poisson relacionadas con la regla del trapecio ==

Como hemos comentado en la introducción, las limitaciones de la fórmula de Poisson provienen principalmente de la aproximación de la integral. En concreto, la fórmula de trapecio que utilizamos incorpora un error en la aproximación y en este apartado vamos a analizar cómo varía en función de la discretización, es decir, en función del número de subintervalos que tomemos para dividir <math> [0,2\pi]</math>.
Para ello, vamos a considerar el mismo problema pero esta vez con la condición frontera
<center><math> g(x,y) = xy </math></center>
Además, vamos a considerar como solución exacta la misma función <math> u(x,y) = xy </math>

[[Archivo:4212ot.png|600px|thumb|center|Solución exacta del problema]]

Con ella calcularemos el error que obtenemos al usar la fórmula de trapecio en un punto lejos de la frontera, en concreto, en <math> (r, \theta) = (0.9, \pi/4) </math>.
Para poder apreciarlo mejor, lo calculamos en escala logarítmica, es decir, si el número de subintervalos es <math> N = 10^n </math> y denotamos <math> u_N </math> la solución obtenida para esta discretización, el error será

<center><math> f(n) = \log_{10} error(10^n) = \log_{10} |u - u_N|</math></center>

Para asegurarnos de que los errores cometidos en la aproximación no son muy grandes y todo va como se espera, vamos a usar una estimación del error de la fórmula del trapecio de Wikipedia. Esta nos dice que, si utilizamos la regla del trapecio para integrar una función <math> f</math> en el intervalo <math> [a,b]</math> con una división en <math> N</math> subintervalos, el error estimado para un valor <math> c \in [a,b]</math> es

<center><math> error(c) = \left|-\frac{(b-a)^3}{12N^2}f''(c)\right|</math></center>

Por tanto, para nuestro caso tomaremos el valor absoluto y tendremos

<center><math> error(c) = \frac{(2\pi)^3}{12N^2}\left|\frac{\partial^2}{\partial \varphi^2}\left(\frac{G(\varphi)}{R^2 + r^2 - 2Rr\cos(\theta^* - \varphi)}\right)_{\varphi = c}\right|</math></center>

donde <math> \theta^*</math> es una constante.

Hemos hecho a mano una acotación del valor absoluto de la doble derivada

<center><math> \left|\frac{\partial^2}{\partial \varphi^2}\left(\frac{G(\varphi)}{R^2 + r^2 - 2Rr\cos(\theta^* - \varphi)}\right)_{\varphi = c}\right| \leq \frac{116}{(1-r)^6} </math></center>

Obteniendo así que, en <math> (r, \theta) = (0.9, \pi/4) </math> el error es

<center><math> error(c) \leq \frac{116(2\pi)^3}{12N^2(1-r)^6} = \frac{232\pi^310^6}{3N^2}</math></center>

A continuación se muestra la representación gráfica del error calculado y el error estimado en el punto <math> (r, \theta) = (0.9, \pi/4) </math>.

[[Archivo:421ot.png|600px|thumb|center|Error calculado y cota del error estimado seún la discretizaión de la fórmula del trapecio]]

===Código===
{{matlab|codigo=
%Resumen de código:
%Para este apartado evaluamos soloamente en el punto (r, theta) = (0.9, pi/4)
%de nuevo con la fórmula de Poisson y esta vez comparamos con la solución
%exacta xy también evaluda en el punto

%condición frontera en polares
g =@(x) sin(x).*cos(x);
R = 1;
imagen_u = 0.9^2*sin(pi/4)*cos(pi/4);
max_exp =8;
errores = zeros(1,max_exp); cota_error_teorico = zeros(1,max_exp);
for n=1:max_exp
%para la regla del trapecio
N=10^n; %número de puntos
a=0; b=2*pi; %extremos del intervalo
h=(b-a)/N; %incremento
u=a:h:b;
w=ones(N+1,1); %vector de pesos
w(1)=1/2; w(N+1)=1/2;

%fórmula de Poisson en el punto
r = 0.9;
z = (pi/4).*ones(1,N+1);
f = (g(u)./(R^2 + r^2 - (2*R*r).*cos(z - u)))';%funcion que integramos
evaluacion = ((R^2 - r^2)/(2*pi))*h*w'*f ;%formula de poisson para coordenadas polares
errores(1,n) = log10(abs(evaluacion - imagen_u));

%acotación de la estimación teórica del error
cota_error_teorico(1,n) = log10(232*(pi)^3*10^6/(3*N^2));
end

figure(1)
hold on
plot(1:max_exp, errores, 'b')
plot(1:max_exp, cota_error_teorico, 'r')
hold off
title('Errores según el exponente del número de puntos de la discretización')
legend("error calculado", "cota error teórico")
xlim([1,max_exp])
ylim([-20,10])
xlabel('exponente del número de puntos de la discretización (10^n)')
ylabel('errores')

}}

Ahora, vamos a calcular el error en distintos puntos. Para ello, fijamos <math> N =100 </math> para la fórmula del trapecio y hacemos que los puntos en los que aplicamos la fórmula de Poisson se vayan acercando a la frontera definiéndolos en coordenadas polares como <math> (r, \theta) = (1 - 10^{-n}, \pi/4) </math>. En consecuancia, la cota estimada del error pasa tener esta forma:

<center><math> error(c) \leq \frac{116(2\pi)^3}{12N^2(1-r)^6} = \frac{232\pi^310^{6n - 4}}{3}</math></center>

Por tanto, a medida que <math> r </math> se acerca a 1, la cota de la estimación teórica se estropea porque tiende a infinito y la gráfica anteriormente realizada queda así:

[[Archivo:422ot.png|600px|thumb|center|Error calculado y cota del error estimado cuando r tiende a 1]]

===Código===
{{matlab|codigo=
%Resumen de código
% Fijamos ahora el número de puntos en la fórmula del trapecio en 100 y
% dibujamos la gráfica del error cuando nos acercamos a la frontera, es decir, para puntos
% de la forma (r, θ) = (1 − 10^−n, π/4).

%condicion frontera (R =1) en polares
g =@(x) sin(x).*cos(x);
R = 1;

%para la regla del trapecio
N=100; %número de puntos
a=0; b=2*pi; %extremos del intervalo
h=(b-a)/N; %incremento
u=a:h:b;
w=ones(N+1,1); %vector de pesos
w(1)=1/2; w(N+1)=1/2;

%comparación de las evaluaciones
max_exp =10;
errores = zeros(1,max_exp);cota_error_teorico2 = zeros(1,max_exp);
for n=1:max_exp
%fórmula de Poisson para cada r en el punto
r = 1 - 10^(-n);
z = (pi/4).*ones(1,N+1); %de nuevo tien que ser vector
imagen_u = r^2*g(pi/4);
f = (g(u)./(R^2 + r^2 - (2*R*r).*cos(z - u)))';%funcion que integramos
evaluacion = ((R^2 - r^2)/(2*pi))*h*w'*f ;%formula de poisson para coordenadas polares
errores(1,n) = log(abs(evaluacion - imagen_u));
cota_error_teorico2(1,n) = log10(232*(pi)^3*10^(6*n-4)/3);
end
%la cota del error teorico no nos sirve cuando r se aproxima a
%1 poeque el denominador de la cota f'' tiende a 0
figure(1)
hold on
plot(1:max_exp, errores, 'b')
plot(1:max_exp, cota_error_teorico2, 'r')
hold off
title('Error y cota estimada del error a medida que r se acerca 1')
legend("error calculado", "cota error teórico")
xlim([1,max_exp])
xlabel('n que hace que r tienda a 1')
ylabel('errores')
}}

== Solución de la Ecuación de Laplace por serie de Fourier ==
En este apartado vamos a hallar la solución del problema anterior por serie de Fourier. Para ello, en primer lugar, planteamos el problema en coordenadas polares:

<center><math> \left\{U_rr + \frac{1}{r}U_r + \frac{1}{r^2}U_{\theta\theta} =0, \hspace{5mm} r \in [0,1), \theta\in [0,2\pi]\atop \hspace{5mm} U = G(\theta) = \sin(\theta)\cos(\theta) \hspace{5mm} \theta\in [0,2\pi] \right. </math> </center>

En la demostración hecha en clase de la fómula de Poisson (existencia de la solución del problema en la bola de radio <math>R</math>) llegamos a que, por el principio de superposicón, una solución de este problema es:

<center><math> U(r,\theta) = \frac{1}{2}a_0 + \sum_{k=1}^{\infty}r^k[a_k\cos(k\theta) + b_k\sin(k\theta)] \hspace{5mm} donde \hspace{5mm} a_0, a_k, b_k \in \mathbb{R} </math> </center>

Por otro lado, escribimos la serie de Fourier de la función <math>G</math>:

<center><math> G(\theta) = \frac{1}{2}\alpha_0 + \sum_{k=1}^{\infty}\alpha_k\cos(k\theta) + \beta_k\sin(k\theta)] </math> </center>

Y con esto, vimos que la condición frontera se satisface si se eligen

<center><math> a_0 = \frac{\alpha_0}{2}, \hspace{5mm} a_k = \frac{\alpha_k}{R} = \alpha_k, \hspace{5mm} b_k = \frac{\beta_k}{R} = \beta_k </math> </center>

Por tanto, si imponemos la condición frontera

<center><math> U(1,\theta) = G(\theta) = \sin(\theta)\cos(\theta) = \frac{1}{2}\sin(2\theta) </math> </center>

deducimos:

<center><math> \alpha_0 = 0, \hspace{5mm} \alpha_k = 0, \hspace{2mm} \forall k \hspace{5mm} \beta_2 = 1/2, \hspace{2mm} \beta_k = 0\forall k \neq 2</math> </center>

Y concluímos que los coeficientes de U deben ser:

<center><math> a_0 = 0, \hspace{5mm} a_k = 0, \hspace{2mm} \forall k \hspace{5mm} b_2 = 1/2, \hspace{2mm} b_k = 0 \hspace{2mm}\forall k \neq 2</math> </center>

Es decir,

<center><math> U(r,\theta) = \frac{1}{2}r^2\sin(2\theta) </math></center>

Terminamos observando que la solución por serie de Fourier tiene un solo término así que no tiene sentido dibujar la gráfica del error en funcón del número de términos.

== Desigualdad de Harnack ==

En esta sección vamos a analizar lo que nos dice las desigualdades de Harnack. Esta es la siguiente: Sea <math>u(x)</math> una función armónica y no negativa, <math>u(x)\geq 0</math> en un dominio <math>\Omega \in \mathbb{R}^n</math> y <math>\mathbb{B}_R(z) \in \Omega</math>. Entonces, para todo <math>x \in \overline{\mathbb{B}_R(z)}</math>,
<center><math>\frac{R^{n-2}(R-r)}{(R+r)^{n-1}}u(z) \leq u(x) \leq \frac{R^{n-2}(R+r)}{(R-r)^{n-1}}u(z)</math>,</center>
donde <math> r = |x-z| </math>.

Como la función <math>u(x,y)=xy</math> es claramente armónica falta comprobar que es no negativa. Para asegurar que es no negativa, vamos a considerar la función armónica y no negativa <math>v(x,y) = u(x,y) - M </math>, donde M es el mínimo de <math>g(x,y) = xy</math> en la frontera <math>\partial \mathbb{B}_1(0)</math>. Se calcula el mínimo M de la función <math>g</math> para cualquier radio R y se obtiene lo siguiente:

<center><math>M = -\frac{R^2}{2} </math></center>

A continuación, aplicamos las desigualdades de Harnack a la función <math>v</math> en la bola <math>\mathbb{b}_R(0)</math> para acotarla de la siguiente manera:

<center><math>\frac{(R-r)}{(R+r)}v(0) \leq v(x) \leq \frac{(R+r)}{(R-r)}v(0)</math>.</center>

Deshaciendo el cambio para encontrar las cotas de las soluciones armónicas y desarrollando los cálculos, se obtiene:

<center><math>M\frac{2r}{R+r} \leq u(x) \leq -M\frac{2r}{R-r} </math></center>

Ahora, sustituyendo el valor de la M, la región donde deben estar las soluciones armónicas en la bola <math>\mathbb{B}_R(0)</math> es:

<center><math> -\frac{R^2r}{R+r} \leq u(x) \leq \frac{R^2r}{R-r} </math></center>

Podemos observar que las cotas solo depende del radio <math>r \in [0,R)</math>.Además, se tiene que la cota inferior dada por la desigualdad de Harnack es siempre negativa.

Vamos a dibujar estas regiones con el siguiente código de matlab para las bolas <math> \mathbb{B}_1(0) </math>,<math> \mathbb{B}_2(0)</math> y <math> \mathbb{B}_{10}(0) </math>:

{{matlab|codigo=
%En este código vamos a representar la región donde deben estar las soluciones a partir de las desigualdades de Harnack para las bolas de radio 1, 2 y 10.

g =@(x,y) y^2.*sin(x).*cos(x); % Condición frontera
R = [1,2,10]; % Radios de las bolas

for k=1:3
M = -R(k)^2/2; % Mínimo de la función de la condición frontera
rmax = R(k)-0.01; num = 100; % rmax es el valor máximo del radio cercano a la frontera y num el número de puntos de la discretización
D = linspace(0, rmax, num); % Vector de la discretización
valores_inferiores = zeros(1,num); valores_superiores = zeros(1,num); % Vector donde se almacena los valores de las cotas inferiores y superiores
for i=1:num
valores_inferiores(i) = -(R(k)^2*D(i))/(R(k)+D(i)); % Cota inferior dada por la desigualdad de Harnack
valores_superiores(i) = (R(k)^2*D(i))/(R(k)-D(i)); % Cota superior dada por la desigualdad de Harnack
end

% Desplazamos los valores de obtenidos para poder aplicar la escala logarítmica
m = min(valores_inferiores);
valores_inferiores = log10(valores_inferiores - (m-1).*ones(1,num));
valores_superiores = log10(valores_superiores - (m-1).*ones(1,num));

% Representación gráfica
figure(k)
hold on
plot(D,valores_inferiores,'r')
plot(D, valores_superiores, 'g')
xlabel('Radios(r)')
ylabel('Cota')
legend('Cota inferior','Cota superior','Location','northwest')
title("Región para la bola de Radio " + num2str(R(k)))
hold off
end
}}

[[Archivo:Radio1.png|400px|thumb|center|Región para la bola de radio 1]]
[[Archivo:Radio2.png|400px|thumb|center|Región para la bola de radio 2]]
[[Archivo:Radio10.png|400px|thumb|center|Región para la bola de radio 10]]

Nótese que como nuestro objetivo es representarlo en escala logarítmica, ya que se aprecia mejor, y la cota inferior siempre toma valores negativo; desplazamos los valores para hacerlos todos positivos y poder reescalar de forma logarítmica. A los valores calculados por la desigualdad de Harnack les restamos el mínimo de ellos, de esta forma son todos positivos.

La región que queda entre las cotas superiores e inferiores proporcionadas por las desigualdades de Harnack es donde deben estar las soluciones armónicas. Se observa que a medida que aumenta el radio de la bola, la cota inferior se va ampliando.

A continuación, vamos a repetir lo anterior pero para dimensión 3. Tomando las mismas funciones <math>u(x,y,z) = xy</math> y <math>g(x,y,z)=xy</math> anteriores pero en dimensión 3, se obtiene el mismo mínimo anterior:

<center><math> M = -\frac{R^2}{2} </math></center>

Con este mínimo y en dimensión 3, las desigualdades de Harnack son:

<center><math> M\frac{r^2 + 3Rr}{(R+r)^2} \leq u(x) \leq M\frac{r^2 - 3Rr}{(R-r)^2} </math></center>

Sustituyendo el valor del mínimo M, nos queda lo siguiente:

<center><math> \frac{-R^2r(r + 3R)}{2(R+r)^2} \leq u(x) \leq \frac{R^2r(3R-r)}{2(R-r)^2} </math></center>

Podemos ver que las cotas solo dependen del radio <math> r \in [0,R)</math> y que la cota inferior toma valores negativos.

Modificamos el código anterior para representar la región dada por las desigualdades de Harnack para las bolas de radio 1, 2 y 10 pero esta vez en dimensión 3.

{{matlab|codigo=
%En este código vamos a representar la región donde deben estar las soluciones a partir de las desigualdades de Harnack para las bolas de radio 1, 2 y 10.

g =@(x,y) y^2.*sin(x).*cos(x); % Condición frontera
R = [1,2,10]; % Radios de las bolas

for k=1:3
M = -R(k)^2/2; % Mínimo de la función de la condición frontera
rmax = R(k)-0.01; num = 100; % rmax es el valor máximo del radio cercano a la frontera y num el número de puntos de la discretización
D = linspace(0, rmax, num); % Vector de la discretización
matriz_inferiores = zeros(1,num); matriz_superiores = zeros(1,num); % Matrices donde se almacena los valores de las cotas inferiores y seperiores
for i=1:num
matriz_inferiores(i) = (-(R(k)^2*D(i))*(D(i)+3*R(k)))/(2*(R(k)+D(i))^2); % Cota inferior dada por la desigualdad de Harnack
matriz_superiores(i) = ((R(k)^2*D(i))*(3*R(k)-D(i)))/(2*(R(k)-D(i))^2); % Cota superior dada por la desigualdad de Harnack
end

% Desplazamos los valores de obtenidos para poder aplicar la escala logarítmica
m = min(matriz_inferiores);
matriz_inferiores = log10(matriz_inferiores - (m-1).*ones(1,num));
matriz_superiores = log10(matriz_superiores - (m-1).*ones(1,num));

% Representación gráfica
figure(k)
hold on
plot(D,matriz_inferiores,'r')
plot(D, matriz_superiores, 'g')
xlabel('Radios(r)')
ylabel('Cota')
legend('Cota inferior','Cota superior','Location','northwest')
title("Región para la bola de Radio " + num2str(R(k)))
hold off
end
}}

[[Archivo:Radio13D.png|400px|thumb|center|Región para la bola de radio 1 en dimensión 3]]
[[Archivo:Radio23D.png|400px|thumb|center|Región para la bola de radio 2 en dimensión 3]]
[[Archivo:Radio103D.png|400px|thumb|center|Región para la bola de radio 10 en dimensión 3]]

Volvemos a desplazar los valores para poder graficar en escala logarítmica ya que los valores de la cota inferior son negativos. En las gráficas podemos ver que tienen la misma forma que en dos dimensiones. Sin embargo, esto es engañoso ya que la solución depende de tres variables, el radio, el ángulo azimutal y el ángulo longitudinal. Entonces en dos dimensiones, la región sería rotar las curvas de las cotas alrededor del eje z; pero en 3 dimensiones, habría que rotarla también alrededor del eje x hasta 180º.

== Ecuación de Poisson en <math> \mathbb{R}^2 </math>. ==
En este apartado daremos solución a un caso concreto de la Ecuación de Poisson. Previamente, mostramos algunas nociones teóricas que serán utilizadas en la resolución del problema.

LLamamos solución fundamental del Laplaciano en <math> \mathbb{R}^2 </math> a la función que viene dada por la expresión <math> \phi (x)=\frac{-1}{2\pi}log(|x|)</math>,
donde <math> log(|x|) </math> recibe el nombre de potencial logarítmico. En clase hemos visto que, utilizando esta expresión, podemos encontrar una única solución para el problema

<center><math> \left\{ -\Delta u=f \hspace{4mm} x\in\mathbb{R}^2 \atop \lim_{|x|\to\infty} u(x)=\frac{-M}{2\pi}log(|x|) + o (\frac{1}{(|x|)}), \hspace{6mm} \text{ donde} \hspace{3mm} M= \int_{\mathbb{R}^2} f(y) dy \right. </math> </center>

que será de la forma

<center> <math> u(x)=\int_{\mathbb{R}^2} \phi(x-y)f(y) dy. </math> </center>

=== El problema ===

En este apartado, intentaremos encontrar una solución para la siguiente ecuación:

<center> <math> \{\hspace{2mm} \Delta u=\mathbb{1}_{\mathbb{B}_1}, \hspace{4mm} x\in\mathbb{R}^2. </math> </center>

Esta ecuación es prácticamente idéntica a la descrita arriba, salvo por un signo negativo. Pero, al ser una ecuación lineal, si cambiamos el signo de la solución habremos obtenido la solución con f cambiada de signo, y puesto que nuestra función f es la característica queda igual. La función solución resultante es:

<center> <math> u(x)=\int_{\mathbb{R}^2} \phi(x-y)f(y) dy = \int_{\mathbb{R}^2} \frac{-1}{2\pi}log(|x-y|) \cdot \mathbb{1}_{\mathbb{B}_1} (y) dy = \int_{\mathbb{B}_1} \frac{-1}{2\pi}log(|x-y|)dy. </math> </center>

Puesto que esta es una integral irresoluble analíticamente, hallaremos una solución numérica. Para ello, primero haremos un cambio de variable para <math> x </math> y pasaremos a coordenadas polares la integral, que después de simplificar resulta:

<center> <math> \left\{ x=(r_xcos(\theta_x),r_xsen(\theta_x)) \atop y=(r_ycos(\theta_y),r_ysen(\theta_y)) \right. \longrightarrow \int_{\mathbb{B}(0,1)} \frac{-1}{2\pi}log(|x-y|)dy= \frac{-1}{4\pi}\int_{0}^{2\pi} \int_{0}^1 r_ylog(r_x^2+r_y^2+cos(\theta_y-\theta_x)) dr_y d\theta_y. </math> </center>

Obteniendo así la función solución en polares

<center> <math> U(r_x,\theta_x)= \frac{-1}{4\pi}\int_{0}^{2\pi} \int_{0}^1 r_ylog(r_x^2+r_y^2+cos(\theta_y-\theta_x)) dr_y d\theta_y, </math> </center>

cuya representación gráfica hecha por Matlab es

[[Archivo:ej5555poison.jpg|500px|thumb|center|Representación gráfica de la solución.]]

{{matlab|codigo=
%Creamos los vectores donde evaluaremos, tanto para x como para y.

Nx=100; Ny=100;
rxi=0; rxf=10; Oxi=0; Oxf=2*pi; ryi=0; ryf=0.9999; Oyi=0; Oyf=2*pi;
rx=linspace(rxi,rxf,Nx); Ox=linspace(Oxi,Oxf,Nx); ry=linspace(ryi,ryf,Ny); Oy=linspace(Oyi,Oyf,Ny);
[RRy,OOy]=meshgrid(ry,Oy);

soluciones=zeros(length(rx),length(Oy));

%fijámos las x, y para cada valor resolvemos la integral bidimensional
%resultante
for i=1:length(rx)
for j=1:length(Ox)
soluciones(i,j)=(-1/(4*pi))*integral2( @(rry,OOy) rry.*log(rx(i).^2+rry.^2-2.*rx(i).*rry.*cos(OOy-Ox(j))) ,ryi,ryf,Oyi,Oyf);
end
end
%Pasamos a cartesianas y ploteamos.
x1=rx'*cos(Ox);
x2=ry'*sin(Ox);
surf(x1,x2,soluciones)

}}

En esta imagen, podemos ver como se cumple el principio del máximo. Si tomamos bolas que no intersequen a <math> B_1 </math> donde el Laplaciano de nuestra función (por la función característica) es cero, la función solución será armónica. Además podemos apreciar que los máximos y mínimos están siempre en las fronteras de dichas bolas, puesto que la función no es constante. Sin embargo, si cogemos cualquier bola que contenga a <math> B_1 </math>, el Laplaciano no será nulo, y de hecho podemos ver que el máximo está en el interior de dichas bolas. Esto es posible porque en esos casos no se cumple el principio del máximo debido a que la solución no es armónica.

Por último, comprobaremos que la solución obtenida tiene el comportamiento esperado en el infinito. Teniendo en cuenta que

<center> <math> M= \int_{\mathbb{R}^2} \mathbb{1}_{\mathbb{B}(0,1)} (y) dy = \pi </math> </center>

se tiene que cuando <math> |x|\to\infty </math> nuestra función debería tener valores prácticamente iguales a <math> \frac{1}{2}log(|x|) </math>. Tomando valores de <math> |x| </math> muy altos y utilizando Matlab obtenemos los siguientes resultados

[[Archivo:ej55tab.png|500px|thumb|center|Comparación de la solución con el comportamiento esperado.]]

{{matlab|codigo=
clear all

%Igual que el programa anterior.
%Variando rxf podemos ver la solución en valores mayores de x
Nx=100; Ny=100;
rxi=0; rxf=10^20; Oxi=0; Oxf=2*pi; ryi=0; ryf=0.9999; Oyi=0; Oyf=2*pi;
rx=linspace(rxi,rxf,Nx); Ox=linspace(Oxi,Oxf,Nx); ry=linspace(ryi,ryf,Ny); Oy=linspace(Oyi,Oyf,Ny);
[RRy,OOy]=meshgrid(ry,Oy);

soluciones=zeros(length(rx),length(Oy));

for i=1:length(rx)
for j=1:length(Ox)
soluciones(i,j)=(-1/(4*pi))*integral2( @(rry,OOy) rry.*log(rx(i).^2+rry.^2-2.*rx(i).*rry.*cos(OOy-Ox(j))) ,ryi,ryf,Oyi,Oyf);
end
end

%Definimos un vector con las imagenes de la función esperada en el infinito
soluciones1=zeros(1,length(rx));
for i=1:length(rx)
soluciones1(i)=(-1/2)*log(rx(i));
end

%mostramos el último valor.
soluciones(100,100)'
soluciones1(100)
}}
verificando así que el comportamiento es el esperado en el infinito.

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T12:31:39Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T12:26:31Z

YanWang: /* Desigualdad de Harnack */

Archivo:Radio103D.png

2024-04-19T12:12:25Z

YanWang:

Archivo:Radio23D.png

2024-04-19T12:12:10Z

YanWang:

Archivo:Radio13D.png

2024-04-19T12:11:56Z

YanWang:

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T12:11:26Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T11:51:02Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T11:41:40Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T09:52:44Z

YanWang: /* Desigualdad de Harnack */

Archivo:Radio10.png

2024-04-19T09:50:26Z

YanWang:

Archivo:Radio2.png

2024-04-19T09:50:08Z

YanWang:

Archivo:Radio1.png

2024-04-19T09:49:11Z

YanWang:

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T09:47:12Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T09:30:37Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T09:28:00Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-19T07:00:27Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:41:26Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:38:09Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:36:40Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:30:21Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:20:52Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:17:52Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:13:50Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T17:13:14Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T16:52:59Z

YanWang: /* Desigualdad de Harnack */

Ecuación de Laplace. Otelo, Yan y Mika

2024-04-18T16:44:53Z

YanWang: /* Desigualdad de Harnack */