MÉTODOS NUMÉRICOS PARA LA ECUACIÓN DE

ONDAS BIDIMENSIONAL

Métodos Matemáticos II
3º Ingeniería Aeronáutica
Curso 2007/2008

Alabort Martínez, Enrique

Baselga Mateo, Ana
García Sánchez, Clara
Martínez Pardo, Carlos
Mora Vargas, Eloy
1 Enunciado
La ecuación de ondas bidimensional es de la forma:

∂ 2u 2⎛∂ u ∂ 2u ⎞
2
= c ⎜ + ⎟ [1]
∂t 2 ⎝ ∂x
2
∂y 2 ⎠

Vamos a considerar esta ecuación en el rectángulo [ −0.5, 0.5] × [ −0.5, 0.5] , con una
condición inicial dada por:

u ( x, y,0 ) = 2cos ( 2π r ) si r ≤ 0.25

u ( x, y, 0 ) = 0 si r > 0.25

siendo r = x 2 + y 2 . La otra condición inicial es:

∂u
( x, y,0 ) = 0
∂t

Suponed condiciones nulas en la frontera.

Resolved el problema mediante un método explícito en el tiempo y el método de Crank-

Nicolson.

Comparad la solución en t = 100 . Para ello, haced una representación gráfica en todo el
rectángulo y de la solución obtenida en la recta y = x, − 0.5 ≤ x ≤ 0.5 .

Figura 1. Condiciones iniciales del problema.

2
2 Método Explícito
En el método explícito se obtiene una solución que depende de las soluciones
anteriores. La discretización temporal y espacial para este método en diferencias finitas
tiene la siguiente forma:
n −1 n +1
∂ 2u ui , j − 2ui , j + ui , j
n

=
∂t 2 Δt 2

∂ 2u ui −1, j − 2ui , j + ui +1, j

n n n

=
∂x 2 Δx 2

∂ 2u ui , j −1 − 2ui , j + ui , j +1
n n n

=
∂y 2 Δy 2

Figura 2. Mallado espacial-temporal para el método explícito (celda computacional).

Si sustituimos la discretización en la ecuación [1] y reordenamos términos, obtenemos:

uin, −j 1 − 2uin, j + uin,+j 1 ⎛ uin−1, j − 2uin, j + uin+1, j uin, j −1 − 2uin, j + uin, j +1 ⎞

=c ⎜2
+ ⎟⎟
Δt 2 ⎜ Δx 2 Δy 2
⎝ ⎠

⎛ 2 ⎛ Δt
2
Δt 2 ⎞ ⎞ ⎛ c 2 Δt 2 ⎞ ⎛ c 2 Δt 2 ⎞ n −1
u n +1
= ui , j ⎜ − c ⎜ 2 + 2 ⎟ ⎟ + ( ui −1, j + ui +1, j ) ⎜
2 n
1 n n
2 ⎟ ( i , j −1
+ u + ui , j +1 ) ⎜
n n
2 ⎟
− ui , j
⎝ Δx Δy ⎠ ⎠ ⎝ Δx ⎠ ⎝ Δy ⎠
i,j
⎝

3
 Δt 2 2 Δt
2
Si definimos r = c 2 y s = c y tenemos en cuenta que nuestro mallado es
Δx 2 Δy 2
regular y uniforme ( Δx = Δy ), obtenemos que r = s , por lo que nuestra ecuación a
resolver queda de la siguiente manera:

uin,+j 1 = uin, j ( 2 − 4r ) + ( uin−1, j + uin+1, j + uin, j −1 + uin, j +1 ) r − uin,−j 1 [2]

Para garantizar la estabilidad del esquema explícito es necesario que se cumpla la

2 Δt
2
condición de Courant: 0 < r = c < 0.5 . Por lo tanto, el paso espacial viene
Δx 2
determinado por el paso temporal que elijamos.

Los valores para n = 0 se obtienen de la condición inicial, pero también son necesarios
los valores para n = 1 . Si usamos la condición de la velocidad:

∂u ui1, j − ui0, j
( x, y,0 )  = 0 → ui1, j = ui0, j
∂t Δt

Este sistema de ecuaciones se puede expresar en forma matricial:

U n +1 = KU n − U n −1 [3]

Donde U n +1 , U n y U n son vectores columna de dimensión N x 2 × 1 en los que se han

colocado las filas de las matrices de manera ordenada:

⎛ u1n,1+1 ⎞ ⎛ u1n,1 ⎞ ⎛ u1n,1−1 ⎞

⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ n +1 ⎟ ⎜ n ⎟ ⎜ n −1 ⎟
⎜ u1,N y ⎟ ⎜ u1,N y ⎟ ⎜ u1,N y ⎟
⎜ n +1 ⎟ ⎜ n ⎟ ⎜ n −1 ⎟
⎜ u2 ,1 ⎟ ⎜ u2 ,1 ⎟ ⎜ u2 ,1 ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ u n +1 ⎟ ⎜ un ⎟ ⎜ u n −1 ⎟
⎜ 2 ,N y ⎟ ⎜ 2 ,N y ⎟ ⎜ 2 ,N y ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
U n +1 = ⎜ ⎟ Un =⎜ ⎟; U n −1 = ⎜ ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ n +1 ⎟ ⎜ n ⎟ ⎜ n −1 ⎟
⎜ u N x −1,1 ⎟ ⎜ u N x −1,1 ⎟ ⎜ u N x −1,1 ⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ u n +1 ⎟ ⎜ un ⎟ ⎜ u n −1 ⎟
⎜ N x −1,Ny ⎟ ⎜ N x −1,Ny ⎟ ⎜ N x −1,Ny ⎟
⎜ u n +1 ⎟ ⎜ u n1 ⎟ ⎜ u n −1 ⎟
⎜ N x ,1 ⎟ ⎜ N x ,1 ⎟ ⎜ N x ,1 ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ u Nn +1,N ⎟ ⎜ u Nn ,N ⎟ ⎜ u Nn −1,N ⎟
⎝ x y ⎠ ⎝ x y ⎠ ⎝ x y ⎠

Para el primer paso temporal, tal y como hemos obtenido anteriormente, U 1 = U 0 .

4
 ⎛ 2 − 4r r 0 0 r 0 " " " " " " ⎞ 0
⎜ r 2 4r r ⎟
⎜ − 0 0 r 0 " " " " " ⎟ 0
⎜ 0 r 2 − 4r r 0 0 % 0 " " " 0 ⎟
"
⎜ ⎟
⎜ 0 0 r 2 − 4r 0 0 % % 0 " " "
0 ⎟
⎜ r 0 0 0 2 − 4r r % % % 0 " " 0 ⎟
⎜ ⎟
⎜ 0 r 0 0 r 2 − 4r % % % % 0 " 0 ⎟
K= ⎜ # % % % % % % % % % % % # ⎟
⎜ ⎟
⎜ 0 " 0 % % % % 2 − 4r r 0 0 r 0 ⎟
⎜ 0 " " 0 % % % r 2 − 4r 0 0 0 r ⎟⎟
⎜
⎜ 0 " " " 0 % % 0 0 2 − 4r r 0 0 ⎟
⎜ ⎟
⎜ 0 " " " " 0 % 0 0 r 2 − 4r r 0 ⎟
⎜ 0 " " " " " 0 r 0 0 r 2 − 4r r ⎟
⎜ ⎟
⎝ 0 " " " " " " 0 r 0 0 r 2 − 4r ⎠

La matriz K es de dimensión N x 2 × N y 2 . El número de ceros entre r y r en la primera

columna y en la primera fila viene determinado por N x − 2 . En las diagonales -1 y 1
cada N x valores hay un 0.

A continuación, hemos desarrollado analíticamente los términos de la ecuación [3] para

un mallado de 4 × 4 y n = 1 con la ayuda del programa Mathematica®:

Como se puede observar, se cumple la ecuación [2], por lo que las matrices son
correctas.
5
Método Crank-Nicolson (CNS)
El método de Crank Nicolson utiliza también un esquema en diferencias finitas. Al
contrario que el esquema explícito, éste no tiene problemas de estabilidad. La
discretización temporal y espacial es la siguiente:
n −1 n +1
∂ 2u ui , j − 2ui , j + ui , j
n

=
∂t 2 Δt 2
n +1 n +1 n +1
∂ 2u ui −1, j − 2ui , j + ui +1, j ui −1, j − 2ui , j + ui +1, j
n n n

= +
∂x 2 Δx 2 Δx 2
n +1 n +1 n +1
∂ 2u ui , j −1 − 2ui , j + ui , j +1 ui , j −1 − 2ui , j + ui , j +1
n n n

= +
∂y 2 Δy 2 Δy 2

Figura 3. Mallado espacial-temporal para el método de CNS (celda computacional).

Si sustituimos la discretización en la ecuación [1] y reordenamos términos, obtenemos:

uin, −j 1 − 2uin, j + uin,+j 1 c 2 ⎛ ⎛ ui −1, j − 2ui , j + ui +1, j ui −1, j − 2ui , j + ui +1, j ⎞

n n n n +1 n +1 n +1

= ⎜⎜ + ⎟⎟ + ...
Δt 2 2 ⎜⎝ ⎜⎝ Δx 2 Δx 2 ⎠
uin,−j 1 − 2uin, j + uin,+j 1 ⎛ uin, j −1 − 2uin, j + uin, j +1 uin,+j −11 − 2uin,+j 1 + uin, +j +11 ⎞ ⎞
..... + ⎜ + ⎟⎟ ⎟⎟ ;
Δt 2 ⎜ Δy 2 Δy 2
⎝ ⎠⎠

6
 c 2 Δt 2 n c 2 Δt 2 n +1
2 ( i −1, j i +1, j ) 2 ( i −1, j
uin,−j 1 − 2uin, j + uin, +j 1 = u − 2u n
+ u n
+ u − 2uin,+j 1 + uin++11, j ) + ...
2Δx 2Δx
i, j

c Δt
2 2
c 2 Δt 2 n +1
2 ( i , j −1
n −1
ui , j − 2ui , j ..... +
n
u − 2ui , j + ui , j +1 ) +
n n n
2 ( i , j −1
u − 2uin,+j 1 + uin,+j +11 ) ;
2Δy 2Δy

⎛ ⎛ Δt 2 Δt 2 ⎞ ⎞ ⎛ c 2 Δt 2 ⎞ n +1 ⎛ c Δt ⎞
2 2
...uin,+j 1 ⎜1 + c 2 ⎜ 2 + 2 ⎟ ⎟ − ( uin−+11, j + uin++11, j ) ⎜ 2 ⎟
− ( u n +1
i , j −1 + u i , j +1 ⎜ ) 2 ⎟
= ...
⎝ ⎝ Δx Δy ⎠ ⎠ ⎝ 2Δx ⎠ ⎝ 2Δy ⎠
⎛ ⎛ Δt 2 Δt 2 ⎞ ⎞ ⎛ c 2 Δt 2 ⎞ ⎛ c 2 Δt 2 ⎞ n −1
..... = 2uin, j ⎜1 − c 2 ⎜ 2 + 2 ⎟ ⎟ + ( uin−1, j + uin+1, j ) ⎜ 2 ⎟
+ ( u n
i , j −1 + u n
)
i , j +1 ⎜ 2 ⎟
− ui ;
⎝ ⎝ Δx Δy ⎠ ⎠ ⎝ 2Δx ⎠ ⎝ 2Δy ⎠

Si procedemos tal y como hemos hecho para el método explícito:

Δt 2 2 Δt
2
r = c2 ; s = c ; Δx = Δy → r = s
Δx 2 Δy 2

uin,+j 1 (1 + 2r ) − ( uin−+11, j + uin++11, j + uin,+j −11 + uin,+j +11 ) = ...

r
2 [4]
... = u n
i,j ( 2 − 2r ) + ( u n
i −1, j +u
n
i +1, j +u
n
i , j −1 +u
n
i , j +1 ) 2r − uin,−j 1
Los valores para n = 0 se obtienen de la condición inicial, pero también son necesarios
los valores para n = 1 . Si usamos la condición de la velocidad:

∂u u −u 1 0

( x, y,0 )  i , j i , j = 0 → ui1, j = ui0, j

∂t Δt

Este sistema de ecuaciones se puede expresar en forma matricial:

AU n +1 = KU n − U n −1 [5]

U n +1 = A−1 ( KU n − U n −1 )

Donde U n +1 , U n y U n son vectores columna de dimensión N x 2 × 1 en los que se han

colocado las filas de las matrices de manera ordenada:

7
 ⎛ u1n,1+1 ⎞ ⎛ u1n,1 ⎞ ⎛ u1n,1−1 ⎞
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ n +1 ⎟ ⎜ n ⎟ ⎜ n −1 ⎟
⎜ u1,N y ⎟ ⎜ u1,N y ⎟ ⎜ u1,N y ⎟
⎜ n +1 ⎟ ⎜ n ⎟ ⎜ n −1 ⎟
⎜ u2 ,1 ⎟ ⎜ u2 ,1 ⎟ ⎜ u2 ,1 ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ u n +1 ⎟ ⎜ un ⎟ ⎜ u n −1 ⎟
⎜ 2 ,N y ⎟ ⎜ 2 ,N y ⎟ ⎜ 2 ,N y ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
U n +1 = ⎜ ⎟ Un =⎜ ⎟; U n −1 = ⎜ ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ n +1 ⎟ ⎜ n ⎟ ⎜ n −1 ⎟
⎜ u N x −1,1 ⎟ ⎜ u N x −1,1 ⎟ ⎜ u N x −1,1 ⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ u n +1 ⎟ ⎜ un ⎟ ⎜ u n −1 ⎟
⎜ N x −1,Ny ⎟ ⎜ N x −1,Ny ⎟ ⎜ N x −1,Ny ⎟
⎜ u n +1 ⎟ ⎜ u n1 ⎟ ⎜ u n −1 ⎟
⎜ N x ,1 ⎟ ⎜ N x ,1 ⎟ ⎜ N x ,1 ⎟
⎜ # ⎟ ⎜ # ⎟ ⎜ # ⎟
⎜ ⎟ ⎜ ⎟ ⎜ ⎟
⎜ u Nn +1,N ⎟ ⎜ u Nn ,N ⎟ ⎜ u Nn −1,N ⎟
⎝ x y ⎠ ⎝ x y ⎠ ⎝ x y ⎠

⎛ 1 + 2r −r 2 0 0 −r 2 0 " " " " " " 0 ⎞

⎜ ⎟
⎜ −r 2 1 + 2r − r 2 0 0 −r 2 0 " " " " " 0 ⎟
⎜ 0 − r 2 1 + 2r − r 2 0 0 % 0 " " " " 0 ⎟
⎜ ⎟
⎜ 0 0 − r 2 1 + 2r 0 0 % % 0 " " " 0 ⎟
⎜ −r 2 0 0 0 1 + 2r − r 2 % % % 0 " " 0 ⎟
⎜ ⎟
⎜ 0 −r 2 0 0 − r 2 1 + 2r % % % % 0 " 0 ⎟
A=⎜ # % % % % % % % % % % % # ⎟
⎜ ⎟
⎜ 0 " 0 % % % % 1 + 2r −r 2 0 0 −r 2 0 ⎟
⎜ 0 " " 0 % % % − r 2 1 + 2r 0 0 0 −r 2 ⎟
⎜ ⎟
⎜ 0 " " " 0 % % 0 0 1 + 2r − r 2 0 0 ⎟
⎜ ⎟
⎜ 0 " " " " 0 % 0 0 − r 2 1 + 2r −r 2 0 ⎟
⎜ 0 " " " " " 0 −r 2 0 0 − r 2 1 + 2r −r 2 ⎟
⎜ ⎟
⎝ 0 " " " " " " 0 −r 2 0 0 −r 1 + 2r ⎠

La matriz A es de dimensión N x 2 × N y 2 . El número de ceros entre − r 2 y − r 2 en la

primera columna y en la primera fila viene determinado por N x − 2 . En las diagonales -
1 y 1 cada N x valores hay un 0.

8
 ⎛ 2 − 4r r 2 0 0 r 2 0 " " " " " " 0⎞
⎜ ⎟
⎜ r 2 2 − 4r r 2 0 0 r 2 0 " " " " " 0⎟
⎜ 0 r 2 2 − 4r r 2 0 0 % 0 " " " " 0⎟
⎜ ⎟
⎜ 0 0 r 2 2 − 4r 0 0 % % 0 " " " 0⎟
⎜ r 2 0 0 0 2 − 4r r 2 % % % 0 " " 0 ⎟
⎜ ⎟
⎜ 0 r 2 0 0 r 2 2 − 4r % % % % 0 " 0 ⎟
K= ⎜ # % % % % % % % % % % % # ⎟
⎜ ⎟
⎜ 0 " 0 % % % % 2 − 4r r 2 0 0 r 0 ⎟
⎜ 0 " " 0 % % % r 2 2 − 4r 0 0 0 r ⎟⎟
⎜
⎜ 0 " " " 0 % % 0 0 2 − 4r r 2 0 0 ⎟
⎜ ⎟
⎜ 0 " " " " 0 % 0 0 r 2 2 − 4r r 2 0 ⎟
⎜ 0 " " " " " 0 r 2 0 0 r 2 2 − 4r r 2 ⎟
⎜ ⎟
⎝ 0 " " " " " " 0 r 2 0 0 r 2 2 − 4r ⎠

La matriz K es de dimensión N x 2 × N y 2 . El número de ceros entre r 2 y r 2 en la

primera columna y en la primera fila viene determinado por N x − 2 . En las diagonales -
1 y 1 cada N x valores hay un 0.

A continuación, hemos desarrollado analíticamente los términos de la ecuación [5] para

un mallado de 4 × 4 y n = 1 con la ayuda del programa Mathematica®:

9
Como se puede observar, se cumple la ecuación [4], por lo que las matrices son
correctas.

10
3 Programación en MATLAB®
A continuación, explicaremos los pasos que se han seguido para implementar los
métodos explícito y Crank-Nicolson en el programa MATLAB®. Para el método
explícito se ha optado por programarlo de dos formas distintas: iterativa y matricial. El
método de Crank-Nicolson sólo se ha implementado matricialmente.

En primer lugar, introducimos las condiciones de nuestro problema:

%% Introducción de las condiciones del problema

clear all
clc
path(path,cd);

dx=1/3; dy=dx; dt=0.02;

L=0.5; x=[-L:dx:L]; y=[-L:dy:L];

c=1;
T=150;
tf=100;
r=(c*dt/dx)^2;

mx=min(x); Mx=max(x); my=min(y); My=max(y);

Nx=length(x); Ny=length(y);
Nt=round(T/dt);

%Condiciones Iniciales
for i=1:Nx
for j=1:Ny
rr(i,j)=sqrt(x(i)^2+y(j)^2);
if rr(i,j)>0.25
U0(i,j)=0;
else
U0(i,j)=2*cos(2*pi*rr(i,j));
end
end
end

%Dibuja condiciones iniciales

surf(x,y,U0);
title({['Método ... :: Distribución de U para t=0
segundos'];['\Deltat=',num2str(dt),' ::
\Deltax=\Deltay=',num2str(dx)]});
xlabel(['X (\Deltax=',num2str(dx),')']); ylabel(['Y
(\Deltay=',num2str(dy),')']); zlabel('U');
axis([mx Mx my My -2 2]);
print('-dpng','-r100','imagen_0');

%Condición de la velocidad
Up0=0*U0;

% Cálculo del primer paso temporal

U1=U0+dt*Up0;

11
A continuación, presentamos el algoritmo que se ha usado para resolver el problema con
el método explícito de forma iterativa:

%% Método explícito iterativo

metodo='explícito (iterativo)';

U0expl=U0; U1expl=U1;

tic

% Iteracion para el resto de pasos temporales

for n=1:Nt
for i=1:Nx
for j=1:Ny

if i==1
if j==1
U{n}(i,j)=2*(1-
2*r)*U1expl(i,j)+r*(U1expl(i+1,j)+U1expl(i,j+1))-U0expl(i,j);
elseif j==Nx
U{n}(i,j)=2*(1-
2*r)*U1expl(i,j)+r*(U1expl(i+1,j)+U1expl(i,j-1))-U0expl(i,j);
else
U{n}(i,j)=2*(1-
2*r)*U1expl(i,j)+r*(U1expl(i+1,j)+U1expl(i,j-1)+U1expl(i,j+1))-
U0expl(i,j);
end

elseif j==1
if i==Nx
U{n}(i,j)=2*(1-2*r)*U1expl(i,j)+r*(U1expl(i-
1,j)+U1expl(i,j+1))-U0expl(i,j);
else
U{n}(i,j)=2*(1-2*r)*U1expl(i,j)+r*(U1expl(i-
1,j)+U1expl(i+1,j)+U1expl(i,j+1))-U0expl(i,j);
end

elseif i==Nx
if j==Ny
U{n}(i,j)=2*(1-2*r)*U1expl(i,j)+r*(U1expl(i-
1,j)+U1expl(i,j-1))-U0expl(i,j);
else
U{n}(i,j)=2*(1-2*r)*U1expl(i,j)+r*(U1expl(i-
1,j)+U1expl(i,j-1)+U1expl(i,j+1))-U0expl(i,j);
end

elseif j==Ny
U{n}(i,j)=2*(1-2*r)*U1expl(i,j)+r*(U1expl(i-
1,j)+U1expl(i+1,j)+U1expl(i,j-1))-U0expl(i,j);

else
U{n}(i,j)=2*(1-2*r)*U1expl(i,j)+r*(U1expl(i-
1,j)+U1expl(i+1,j)+U1expl(i,j-1)+U1expl(i,j+1))-U0expl(i,j);

12
 end

end
end
U0expl = U1expl; U1expl = U{n};
end

tcalc(1)=toc;
size=whos('U');
size=size.bytes; size=size/(1024)^2;

fprintf('El tiempo de cálculo ha sido %g segundos y el tamaño de U es

%g MB\n\n',tcalc(1),size);
Uexplit=U{tf/dt};

El motivo de por qué se han tenido que usar tantas sentencias de tipo if es porque hay
que tener especial cuidado con los valores de la frontera. Cada solución en cada instante
de tiempo es almacenada en un cell array.

Para el método explícito resuelto de forma matricial:

%% Método explícito Matricial

metodo='explícito (matricial)';

tic

E=ones(Nx^2,1);
ceros=zeros(Nx^2,Nx-2);
r1=r*E;
r2=r1; r2(Nx:Nx:Nx^2,1)=0; r3=flipud(r2);

diagsK=[r1 ceros r2 (2-4*r)*E r3 ceros r1];

K=spdiags(diagsK,-Nx:Nx,Nx^2,Ny^2);
U0t=U0'; U1t=U1';
U0vect=U0t(:); U1vect=U1t(:);

%Iteración para el resto de pasos temporales

for n=1:Nt
Uvect=K*U1vect-U0vect;
U0vect = U1vect; U1vect = Uvect;
for i=1:Nx
U{n}(i,:)=Uvect((i-1)*Ny+1:i*Ny); % Convierte a Matriz
end
end

tcalc(2)=toc;
mb=whos('U');
mb=mb.bytes; mb=mb/(1024)^2;

fprintf('El tiempo de cálculo ha sido %g segundos y el tamaño de U es

%g MB\n\n',tcalc(2),mb);
Uexplmat=U{tf/dt};

La matriz K se ha construido a partir de sus diagonales. Se ha optado por una matriz

dispersa con el fin de ahorrar espacio en memoria. Cada solución en cada instante de
tiempo es almacenada en un cell array.
13
Por último, para el método de Crank-Nicolson:

%% Método Crank-Nicolson

metodo='Crank-Nicolson';

tic

E=ones(Nx^2,1);
ceros=zeros(Nx^2,Nx-2);
r1=r/2*E;
r2=r1; r2(Nx:Nx:Nx^2,1)=0; r3=flipud(r2);

diagsK=[r1 ceros r2 (2-2*r)*E r3 ceros r1];

K=spdiags(diagsK,-Nx:Nx,Nx^2,Ny^2);
diagsA=[-r1 ceros -r2 (1+2*r)*E -r3 ceros -r1];
A=spdiags(diagsA,-Nx:Nx,Nx^2,Ny^2);

U0t=U0'; U1t=U1';
U0vect=U0t(:); U1vect=U1t(:);

%Iteración para el resto de pasos temporales

for n=1:Nt
Uvect=A\(K*U1vect-U0vect);
U0vect = U1vect; U1vect = Uvect;
for i=1:Nx
U{n}(i,:)=Uvect((i-1)*Ny+1:i*Ny); % Convierte a Matriz
end
end

tcalc(3)=toc;
mb=whos('U');
mb=mb.bytes; mb=mb/(1024)^2;

fprintf('El tiempo de cálculo ha sido %g segundos y el tamaño de U es

%g MB\n\n',tcalc(3),mb);
Ucrank=U{tf/dt};

Al igual que anteriormente, las matrices A y K se han construido a partir de sus

diagonales. Se ha optado por matrices dispersas con el fin de ahorrar espacio en
memoria. Cada solución en cada instante de tiempo es almacenada en un cell array.

Con el fin de poder dibujar la evolución del sistema se han elaborado vídeos. Estos
videos se han montado fotograma a fotograma:

%% Obtener Fotogramas
for i=1:60/dt
surf(x,y,U{i});
title({['Método ',metodo,' :: Distribución de U para
t=',num2str(i*dt),' segundos'];['\Deltat=',num2str(dt),' ::
\Deltax=\Deltay=',num2str(dx)]});
xlabel(['X (\Deltax=',num2str(dx),')']); ylabel(['Y
(\Deltay=',num2str(dy),')']); zlabel('U');
axis([mx Mx my My -2 2]);
name=['imagen_',num2str(i)];
print('-dpng','-r100',name)
end

14
4 Resultados
Se ha elegido un paso temporal de 0.02 segundos y un paso temporal de 0.04 metros.
Por lo tanto, se cumple la condición de estabilidad para el método explícito.

Con el fin de facilitar la impresión de los resultados en forma de gráfico, se ha

programado el siguiente código en MATLAB®:

%% Ejercicio explicito iterativo

surf(x,y,Uexplit)
title({['Método explícito (iterativo) :: Distribución de U para
t=',num2str(tf),' segundos'];['\Deltat=',num2str(dt),' ::
\Deltax=\Deltay=',num2str(dx)]});
xlabel(['X (\Deltax=',num2str(dx),')']); ylabel(['Y
(\Deltay=',num2str(dy),')']); zlabel('U');
axis([mx Mx my My -2 2]);
print('-dpng','-r100','ondas2D_explicito_iterativo_U_3D_t100')
pause
plot(x,diag(Uexplit))
title({['Método explícito (iterativo) :: Distribución de U para
t=',num2str(tf),' segundos en la recta y=x'];['\Deltat=',num2str(dt),'
:: \Deltax=\Deltay=',num2str(dx)]});
print('-dpng','-r100','ondas2D_explicito_iterativo_U_2D_y=x_t100')

%% Ejercicio explicito matricial

surf(x,y,Uexplmat)
title({['Método explícito (matricial) :: Distribución de U para
t=',num2str(tf),' segundos'];['\Deltat=',num2str(dt),' ::
\Deltax=\Deltay=',num2str(dx)]});
xlabel(['X (\Deltax=',num2str(dx),')']); ylabel(['Y
(\Deltay=',num2str(dy),')']); zlabel('U');
axis([mx Mx my My -2 2]);
print('-dpng','-r100','ondas2D_explicito_matricial_U_3D_t100')
pause
plot(x,diag(Uexplmat))
title({['Método explícito (matricial) :: Distribución de U para
t=',num2str(tf),' segundos en la recta y=x'];['\Deltat=',num2str(dt),'
:: \Deltax=\Deltay=',num2str(dx)]});
print('-dpng','-r100','ondas2D_explicito_matricial_U_2D_y=x_t100')

%% Ejercicio Crank-Nicolson

surf(x,y,Ucrank);
title({['Método Crank-Nicolson :: Distribución de U para
t=',num2str(tf),' segundos'];['\Deltat=',num2str(dt),' ::
\Deltax=\Deltay=',num2str(dx)]});
xlabel(['X (\Deltax=',num2str(dx),')']); ylabel(['Y
(\Deltay=',num2str(dy),')']); zlabel('U');
axis([mx Mx my My -2 2]);
print('-dpng','-r100','ondas2D_crank-nicolson_U_3D_t100')
pause
plot(x,diag(Ucrank));
title({['Método Crank-Nicolson :: Distribución de U para
t=',num2str(tf),' segundos en la recta y=x'];['\Deltat=',num2str(dt),'
:: \Deltax=\Deltay=',num2str(dx)]});
print('-dpng','-r100','ondas2D_crank-nicolson_U_2D_y=x_t100')

15
Además de las gráficas que a continuación se adjuntan, se han elaborado vídeos de un
minuto en los que se muestran la evolución temporal del sistema para cada uno de los
métodos. A continuación se muestran las gráficas para los instantes de tiempo 2, 5, 10,
20, 50 y 100 segundos de cada uno de los métodos. Se muestra tanto la distribución de
U en todo el rectángulo como en la recta y = x :

Para t=2 s:

16
Para t=5 s:

17
Para t=10 s:

18
Para t=20 s:

19
Para t=50 s:

20
Para t=100 s:

A la vista de los resultados, podemos concluir que existe un error en el método de

Crank-Nicolson que hemos implementado, aunque no hemos podido localizar dónde. Al
principio, el método CNS es similar al explícito, pero conforme avanza el tiempo, el
modelo de CNS se va amortiguando y la membrana deja de vibrar. Como era de esperar,
las dos formas en las que hemos desarrollado el método explícito producen resultados
similares.

21