Examen 1er Parcial

Dinámica de Fluidos Computacional

López Briones Yael Fernando

Profesor: Rafael Medina Noguerón

8AV2
19 - Marzo - 2019

1. Problema la onda no atravesará. Se muestra además el origen

de la fuente con ondas en azul y demás condiciones
Realizar la simulación de una fuente impactando con geométricas.
fronteras reflexivas usando la ecuación de onda:
Condiciones de Frontera
∂2u
 2
∂ u ∂2u

=a + 2 (1)
∂t2 ∂x2 ∂y Para las fronteras reflexivas se debe cum-
plir:
u = 0 para x = 7,475 m ; 0 < y < 3,75 m
u = 0 para x = 7,475 m ; 6,25m < y < Ly
u = 0 para x = 7,525 m ; 0 < y < 3,75 m
u = 0 para x = 7,525 m ; 6,25m < y < Ly
Además de:
u = 0 para 7,475 m < x < 7,525m ; y = 3,75 m
u = 0 para 7,475 m < x < 7,525m ; y = 6,25 m
y para la pared posterior:
u = 0 para x = Lx ; 0 < y < Ly

Condiciones Iniciales

Se usará una fuente: u = A sin (ωt) en

x = 14 L ; y = 12 L
u = 0 en cualquier otro lugar
Figura 1: Gráfica con la geometrı́a de la simulación Condiciones Adicionales

Para la discretización se utilizará el méto-

En este caso, las lı́neas marcadas en rojo serán las do de diferencias finitas con centrales de
fronteras reflexivas, que actuarán como una pared que segundo orden para las derivadas parciales de

1
2 DESARROLLO 2

segundo grado Por lo tanto, el código es usado y modificado para

Lx = 10 m adecuarlo a las condiciones de frontera especificadas
Ly = 10 m en este problema.
2
a = 2500/9801 m s2 (Velocidad de propragación
elevada al cuadrado) En la primera parte del código se declaran las
∆t = 0,1 s constantes a utilizar, ası́ como las dimensiones del
f = 0,75 1s espacio bidimensional, número de nodos y tiempo de
ω = 2πf la simulación.
A = ∆t2 ∗ 800 (Amplitud de la onda)
100 nodos en x (nx = 100) En esta primera parte, también se declaran las carac-
100 nodos en y (ny = 100) terı́sticas de la onda sinusoidal, como su frecuencia y
amplitud. Estas constantes se eligieron con base en
el código de referencia, para simular la fuente lo más
2. Desarrollo uniformemente posible.
Usando el método de las diferencias finitas, junto con En este caso, tanto ∆x como ∆y tienen la misma
las condiciones adicionales, se discretiza la ecuación dimensión√ y el número
(1): ∆t √ ∆t de Courant es el mismo
(CF L = a ∆x = a ∆y ).
un+1
i,j
−2un n−1
i,j +ui,j
 n ∆t 2 = Se declaran tres arreglos bidimensionales para los
ui+1,j −2un n
un n n 
i,j +ui−1,j i,j+1 −2ui,j +ui,j−1 valores de la variable u, uno que guarda el valor
a ∆x2 + ∆y 2
actual y otros dos con el valor posterior y anterior
Despejando a un+1 i,j : (unp1 = un+1 n−1
i,j y unm1 = ui,j )
2
un+1 ∆t


i,j = a ∆x 2 uni+1,j − 2uni,j + uni−1,j +
Posteriormente se le da inicio al bucle desde el tiempo
∆t2
ui,j+1 − 2ui,j + ui,j−1 + 2uni,j − un−1
n n n


a ∆y 2 i,j 0, declarando las condiciones de la frontera transpa-
rente en los bordes de la imagen, en las partes dónde
Por conveniencia, se usarán: no exista una barrera. En este caso se usó el código
∆t2 de UNLV, con las condiciones de frontera absorsivas
α=a de Mur:
∆x2  
y: δu  δu 
= CF L
δx  x=0 δt x=0
∆t2
β=a
∆y 2
 
δu  δu 
= CF L 
Quedando: δy 0<x< 299 L;y=0 δt 0<x< 299 L;y=0
400 400

un+1


= α uni+1,j − 2uni,j + uni−1,j +
 
i,j δu  δu 
= CF L
β uni,j+1 − 2uni,j + uni,j−1 + 2uni,j − un−1


i,j δy  301 L<x< 399 L;y=0 δt  301 L<x< 399 L;y=0
400 400 400 400

Para este código se usó como apoyo el código de 

δu 

δu 
CEE 709 Numerical Methods in Mechanics, = −CF L 
δy 0<x< 299 L;y=Ly δt 0<x< 299 L;y=Ly
de la University of Nevada, Las Vegas [1]. 400 400

En este código se simula una fuente y se cambian  

las fronteras a reflexivas a absorsivas o transparentes. δu  δu 
= −CF L 
δy  301 L<x< 399 L;y=Ly δt 301 L<x< 399 L;y=Ly
400 400 400 400
2 DESARROLLO 3

Las cuales son discretizadas en el código, obsérvese 14 %Tiempo de simulacin

que se evitan los puntos de x donde existe una 15 nt=50;
16 %Caractersticas fuente
frontera reflexiva. 17 f=15/20;
18 w=2*pi*f;
Ahora se inicia con la solución del código, usando un 19 A=dtˆ2*800;
bucle while para resolverlo hasta el tiempo especifi- 20 %Consantes y N mero de Courant
21 alpha=a*dtˆ2/dxˆ2;
cado y declarando en primer lugar las condiciones de 22 beta=a*dtˆ2/dyˆ2;
frontera absorsivas. 23 CFL=sqrt(a)*dt/dx;
24 %Variables para el tiempo anterior y
posterior
Posteriormente se aumenta un valor de ∆t para cada
25 un=zeros(nx,ny);
buble del while, además de asignar al valor previo 26 unm1=un;
de u el valor actual (un−1 = un ) y al valor actual el 27 unp1=un;
valor posterior (un = un+1 ). Esto con el fin de iniciar 28 %Inicio del Loop
29 t=0;
el bucle desde un tiempo en el que ya se conozcan 30 fig num=1; % sets number of figure to be
los valores previos de u, ya que se requiere un−1 . opened
31 while(t<nt)
A continuación se incluye el valor de la fuente y su 32 %Absorbing Boundary Conditions
33 unp1(1,:)=un(2,:)+((CFL−1)/(CFL+1))
posición, junto con la ecuación a resolver (un+1
i,j ) *(unp1(2,:)−un(1,:));
para los puntos internos de los nodos. 34 unp1(1:int8(299/400*nx),1)=un(1:int8
(299/400*nx),2)+((CFL−1)/(CFL+1)
)*(unp1(1:int8(299/400*nx),2)−un
Después se incluyen las condiciones de la frontera
(1:int8(299/400*nx),1));
reflexiva en las posiciones especı́ficadas y ahora, 35 unp1(int8(301/400*nx):end−1,1)=un(
fuera del ciclo de solución, se incluyen otros valores int8(301/400*nx):end−1,2)+((CFL
para la visualización de esa barrera. −1)/(CFL+1))*(unp1(int8(301/400*
nx):end−1,2)−un(int8(301/400*nx)
:end−1,1));
Finalmente se hacen las gráficas de la solución de 36 unp1(1:int8(299/400*nx),end)=un(1:
manera bidimensional y usando un mallado. Es int8(299/400*nx),end−1)+((CFL−1)
importante recalcar que en este caso se usan esta- /(CFL+1))*(unp1(1:int8(299/400*
nx),end−1)−un(1:int8(299/400*nx)
blecen lı́mites de color para facilitar la visualización, ,end));
además de rotar la imagen para visualizar mejor la 37 unp1(int8(301/400*nx):end−1,end)=un(
onda e incluir el código para crear una animación int8(301/400*nx):end−1,end−1)+((
GIF. CFL−1)/(CFL+1))*(unp1(int8
(301/400*nx):end−1,end−1)−un(
int8(301/400*nx):end−1,end));
Se incluye el código final: 38 %Solution
39 t=t+dt;
40 unm1=un;
1 clear all 41 un=unp1; %Save current and previous
2 clc arrays
3 %Dimensiones 42 un(int8(nx/4),int8(ny/2))=A*sin(w*t)
4 Lx=10; ; %Source
5 Ly=10; 43 for i=2:nx−1
6 nx=100; 44 for j=2:ny−1
7 ny=100; 45 unp1(i,j)=2*un(i,j)−unm1(i,j
8 dx=Lx/(nx−1); )+alpha*(un(i+1,j)−2*un(
9 dy=Ly/(ny−1); i,j)+un(i−1,j))+beta*(un
10 x=linspace(0,Lx,nx); (i,j+1)−2*un(i,j)+un(i,j
11 y=linspace(0,Ly,ny); −1));
12 a=2500/9801; 46 %Reflecting Boundary
13 dt=0.1;
3 RESULTADOS 4

Conditions 87 filename = 'GIF.gif';

47 un(int8(299/400*nx),1:int8 88 del = 0.1; % time between animation
(3/8*ny))=0; frames
48 un(int8(299/400*nx),int8 89 drawnow
(5/8*ny):end)=0; 90 frame = getframe(fig num);
49 un(int8(300/400*nx),1:int8 91 im = frame2im(frame);
(3/8*ny))=0; 92 [imind,cm] = rgb2ind(im,256);
50 un(int8(300/400*nx),int8 93 if t==dt
(5/8*ny):end)=0; 94 imwrite(imind,cm,filename,'gif',
51 un(int8(301/400*nx),1:int8 'Loopcount',inf);
(3/8*ny))=0; 95 else
52 un(int8(301/400*nx),int8 96 imwrite(imind,cm,filename,'gif',
(5/8*ny):end)=0; 'WriteMode','append','
53 un(end,:)=0; DelayTime',del);
54 end 97 end
55 end 98 end
56 %Visualizacin de la Barrera
57 un(int8(299/400*nx),1:int8(3/8*ny))
=1.6;
58 un(int8(299/400*nx),int8(5/8*ny):end
)=1.6;
59 un(int8(301/400*nx),1:int8(3/8*ny))
=1.6;
un(int8(301/400*nx),int8(5/8*ny):end
60
)=1.6; 3. Resultados
61 un(int8(299/400*nx):int8(301/400*nx)
,int8(3/8*ny))=1.6;
62 un(int8(299/400*nx):int8(301/400*nx) Se muestra el sistema con las condiciones iniciales:
,int8(5/8*ny))=1.6;
63 un(end,:)=1.6;
64
65 figure(fig num)
66 subplot(2,2,1);
67 imagesc(x,y,un'); colorbar; caxis
([−1.6 1.6]);
68 title(sprintf('t = %.2f',t));
69
70 subplot(2,2,2);
71 m=mesh(x,y,un'); colorbar; caxis
([−1.6 1.6]);
72 axis([0 Lx 0 Ly 0 1.6]);
73 direction=[0 0 1];
74 rotate(m,direction,175)
75
76 subplot(2,2,3);
77 m=mesh(x,y,un'); colorbar; caxis
([−1.6 1.6]);
78 axis([0 Lx 0 Ly 0 1.6]);
79
80 subplot(2,2,4);
Figura 2: Simulación de u(x, y, t) para el tiempo t =
81 m=mesh(x,y,un'); colorbar; caxis 0,00 s
([−1.6 1.6]);
82 axis([0 Lx 0 Ly 0 1.6]);
83 direction=[0 0 1];
84 rotate(m,direction,−32)
85
86 pause(0.001); Se muestra el sistema para t = 0,10 s, momento en
el que se visualiza la fuente:
3 RESULTADOS 5

Figura 3: Simulación de u(x, y, t) para el tiempo t = Figura 5: Simulación de u(x, y, t) para el tiempo t =
0,10 s 15,00 s

Se incluyen imagenes con diferentes vistas para notar

Se muestra el sistema para t = 10,00 s, momentos mejor este efecto. Obsérvese además como la onda no
antes de que la onda impacte con las barreras: es reflejada en los demás bordes de la simulación, sino
que se sigue propagando debido a las condiciones de
Mur:

Figura 6: Simulación de u(x, y, t) para el tiempo t =

Figura 4: Simulación de u(x, y, t) para el tiempo t = 15,00 s
10,00 s

Se muestra el sistema para t = 50,00 s, la onda es

reflejada en el extremo derecho de la simulación y se
Se muestra el sistema para t = 15,00 s, la onda ya ha sigue propagando en los bordes superior e inferior,
impactado con las barreras y es reflejada: siendo reflejada en las barreras:
4 CONCLUSIONES 6

manera apropiada.

Esto nos permite confirmar la utilidad del método

de diferencias finitas, ya que en este caso se puede
obtener de manera precisa una simulación de una
onda siendo propagada en el espacio bidimensional y
observar los efectos al impactarla con barreras.

El uso de las condiciones de frontera reflexivas y

de Mur es resaltado ya que simulan de manera
apropiada los casos en que la onda impacta contra
algún obstáculo o necesita ser propagada a través de
un medio. Es importante aclarar que para el caso
Figura 7: Simulación de u(x, y, t) para el tiempo t = de las fronteras absorsivas éstas no son totalmente
50,00 s ”transparentes”, ya que, como se comenta en las
referencias, no hay como tal una frontera totalmente
”transparente”
Imagenes adicionales para el mismo tiempo:
Finalmente, es remarcada la importancia de la
dinámica de fluidos computacional, ya que con los
métodos de diferencias finitas se pueden observar re-
sultados precisos de simulaciones que se aplican a
problemas de ingenierı́a. Sin embargo, es necesario
aclarar que se debe tener cuidado al realizar las si-
mulaciones, ya que el proceso de discretizar las ecua-
ciones y programarlas es crı́tico en la exactitud de la
solución.

Referencias
[1] Haroon StephenNumerical Methods in Mecha-
Figura 8: Simulación de u(x, y, t) para el tiempo t = nics https://hstephen.faculty.unlv.edu/teaching-
50,00 s 2/cee-709/ Consulta el 19 de Marzo del 2019.

[2] John D. Anderson, Jr. Computational Fluid

Después de este tiempo simulación es estable. Dynamics McGraw-Hill, Inc.

4. Conclusiones [3] MATLAB Answers All figures in

subplot saved to animated gif file.
En conclusión, es posible simular la fuente y las https://la.mathworks.com/matlabcentral/answers/
barreras reflexivas y absorsivas discretizando la 385451-all-figures-in-subplot-saved-to-animated-
ecuación de la onda y programando un código de gif-file Consulta el 19 de Marzo del 2019.