Flyer de présentation de Caritas en marche

ENP TP3 : Correction
Wietze Herreman, janvier 2014
Contents
Onde propagative en 1 dimension
Onde stationnaire en 1 dimension
Onde circulaire a deux dimensions (methode 1)
Onde circulaire a deux dimensions (methode 2)
Interference de deux ondes circulaires
Diffraction d'une one plane
Onde propagative en 1 dimension
Commencons par definir l'amplitude, la longueur d'onde, la vitesse de propagation.
A=1;
lambda=1;
c=1/2;
On fera une animation pour des temps t allant de 0 a T, par petit pas de dt. Por faire la
courbe, il est necessaire d'introduire un maillage de l'espace entre x=0 et x=L, par pas de dx.
dt=0.01;
dx=0.01;
L=5;
T=2;
x=0:dx:L;
for t=0:dt:T
u=A*cos(2*pi/lambda*(x-c*t));
plot(x,u)
xlabel('x')
ylabel('amplitude')
title('Onde propagative 1D')
drawnow
end
Il n'est evidemment pas possible d'imprimer l'animation. Remarque que l'on compte
exactement 5 longueurs d'ondes dans notre figure. Il est necessaire de choisir dx suffisament
petit pour avoir une courbe visuellement lisse.
Onde stationnaire en 1 dimension
Une onde stationnaire est une superposition d'une onde propagant a droite et une propagant a
gauche. Pour faire l'animation, nous avons
for t=0:dt:T
%
vers a droite
vers la gauche
u=A*cos(2*pi/lambda*(x-c*t)) + A*cos(2*pi/lambda*(x+c*t)) ;
plot(x,u)
% Il est necessaire de fixer les echelles verticales pour eviter que matlab
% change les axes.
ylim([-2*A,2*A])
xlabel('x')
ylabel('amplitude')
title('Onde stationnaire 1D')
drawnow
end
Si les deux ondes n'ont pas la meme amplitude, la superposition des deux ne sera pas
stationnaire.
Onde circulaire a deux dimensions (methode 1)
Il est necessaire d'introduire un maillage de l'espace en deux dimensions. Pour cela, on
commence avec un maillage selon x et y
x=0:0.01:1;
y=0:0.01:1;
Ensuite, nous utilisons
[X,Y]=meshgrid(x,y);
pour faire un mailage 2D (voir TP1). Le code suivant realise l'animation souhaitee
xs=0.5;
ys=0.5;
lambda=0.1;
A=1;
for t=0:dt:T
R=sqrt((X-xs).^2+(Y-ys).^2);
u=A./sqrt(R).*cos(2*pi/lambda*(R-c*t));
ent par element
pcolor(x,y,u)
colorbar
%puissance element par element .^
% division et multiplication ./ et .* elem
% la fonction u(x,y) en code couleur
% legende pour les couleurs
caxis([-2*A,2*A])
shading flat
% fixer les echelles de couleur
% enlever le maillage dans la figure
axis equal
x et y
xlabel('x')
ylabel('y')
title('Onde circulaire 2D')
% utiliser les mes echelles pour les axes
drawnow
end
Onde circulaire a deux dimensions (methode 2)
Au lieu d'utiliser la commande meshgrid pour faire un maillage en 2D, nous pouvons
manuellement programmer le remplissage de la matrice u, qui contiendra les valeur du
champ u, sur les points de la maille. Le code suivant realise cet exploit.
x=0:0.01:1;
y=0:0.01:1;
u=zeros(length(x),length(y));
%initialisation u
xs=0.5;
ys=0.5;
lambda=0.1;
A=1;
for t=0:dt:T
%remplir la matrice manuellement, element par element
for i=1:length(x)
for j=1:length(y)
r=sqrt((x(i)-xs)^2+(y(j)-ys)^2);
u(i,j)=A/sqrt(r)*cos(2*pi/lambda*(r-c*t));
end
end
pcolor(x,y,u)
colorbar
caxis([-2*A,2*A])
shading flat
axis equal
xlabel('x')
ylabel('y')
title('Onde circulaire 2D')
drawnow
end
Cette methode est plus proche de ce qu'on ferait, si on devrait utiliser un langange de
programmation autre que Matlab. On remplit tout simplement les elements d'une matrice, 1
par 1. Cette methode est donc peut etre plus simple a comprendre et elle donnne une
meilleure comprehension de ce qui se passe veritablement.
D'un point de vue, vitesse de calcul et nombre d'instructions, la premiere methode est
preferable, mais nous avouons egalement qu'elle est peut etre plus abstraite. Vous choisissez
la methode que vous voulez !
Interference de deux ondes circulaires
Pour faire interferer deux ondes, nous placons les deux sources aux endroits specifies. Ceci
peut se faire manuellement ou a l'aide d'une boucle
xs=[0.3,0.7];
ys=[0.5,0.5];
A=[1,1];
for t=0:dt:T
u=zeros(size(X));
for n=1:length(xs)
R=sqrt((X-xs(n)).^2+(Y-ys(n)).^2);
u=u+A(n)./sqrt(R).*cos(2*pi/lambda*(R-c*t));
end
pcolor(x,y,u)
colorbar
caxis([-2,2])
shading flat
axis equal
xlabel('x')
ylabel('y')
title('interference en 2D')
drawnow
end
Suite a l'interference, il y a des endroits dans l'espace ou les amplitudes des deux ondes
s'ajoutent (interference constructive) et d'autres endroits ou c'est l'inverse (interference
destructive). Si la distance entre les sources est grande par rapport a la longueur d'onde, les
deux sources agiront comme une seule et vous ne verez plus d'interferences. Dans le cas
inverse on observe de plus en plus d'interferences.
Grace a la boucle, le meme programme peut maintenant etre legerement modifie pour faire
interferer plus que deux sources, par exemple, il suffira de modifier
xs=[0.3,0.7,0.5,0.5];
ys=[0.5,0.5,0.3,0.7];
pour faire interferer des ondes emanant de quatre sources.
Diffraction d'une one plane
Comme exemple d'un plus grand nombre de sources en interference, nous considerons le cas
special ou nous mettons (un grand nombre) une vingtaine de sources (Ns=20) en xs=0 entre
ys=0.4 et ys=0.6. Nous utilisons exactement la meme boucle que precedemment
Ns=20; %vingt sources
xs=zeros(1,Ns);
ys=linspace(0.4,0.6,Ns); %positions
A=ones(1,Ns);
%amplitudes
for t=0:dt:T
u=zeros(size(X));
%n'oublier pas cette initialisation
%a chaque temps, nous calculons une nouvelle
%superposition d'onde = une nouvelle somme
for n=1:length(xs)
R=sqrt((X-xs(n)).^2+(Y-ys(n)).^2);
u=u+A(n)./sqrt(R).*cos(2*pi/lambda*(R-c*t));
end
pcolor(x,y,u)
colorbar
caxis([-2*Ns,2*Ns])
shading flat
%adapter l'echelle de couleur
axis equal
xlabel('x')
ylabel('y')
title('Diffraction en 2D')
drawnow
end
Nous voyons que les 20 sources rapprochees agissent comme une source unique en forme de
barreau. Ceci illustre le principe de Huygens. La figure obtenue, est celle que l'on verrait
derriere une fente sur laquelle tombe une onde plane. On remarque que l'onde a une forte
amplitude dans certaines directions, mais faibles dans d'autres directions. Ce phenomene est
connu sous le nom de la diffraction.
Published with MATLAB® 7.10

Download Report