Groupe :
NOM Prénom des personnes du groupe:
Le TP doit être rendu sous la forme d'un Notebook jupyter en respectant la nomenclature suivante:
En remplaçant N par le numéro de votre groupe. Tous les résultats, discussions, analyses, doivent donc être inclus dans le fichier.
Vous pouvez vous familiariser avec les notions de Python utiles pour ce TP dans ce Notebook.
On se propose dans se TP de simuler numériquement l'apparition des franges d'interférences en aval de fentes d'Young acoustiques à l'aide d'un code Lattice Boltzmann $D2Q4$ écrit en Python.
Le modèle à 4 vitesses de la méthode de Boltzmann sur réseau est un modèle linéaire permettant de résoudre les équations de propagation d’ondes - type d’Alembert ou Helmholtz - et son algorithme s’exprime de façon très simple. Les paramètres du modèle sont résumés dans le tableau suivant:
| $c_\alpha$ | $\omega_\alpha$ | $c_0$ | $\tau_g$ |
| (1,0) (0,1) (-1 0) (0 -1) | $\dfrac{1}{4},\dfrac{1}{4},\dfrac{1}{4},\dfrac{1}{4}$ | $\dfrac{1}{\sqrt{2}}$ | $\dfrac{1}{2}$ |
La fonction d'équilibre du modèle s'écrit: $$ \displaystyle{g_{\alpha}^{eq}=\rho\omega_\alpha +\omega_\alpha\dfrac{(g_1-g_3).c_{\alpha,x}+(g_2-g_4).c_{\alpha,y}}{c_0^2}} $$
et son algorithme général: $$ \displaystyle{g_{\alpha}^{coll} = g_{\alpha}-\dfrac{1}{\tau_g}[g_{\alpha}-g_{\alpha}^{eq}]\\ g_{\alpha}(x,y,t) = g_{\alpha}^{coll}(x-c_{\alpha,x},y-c_{\alpha,y},t)} $$
Les variables macroscopiques sont calculées à partir des moments des fonctions de distribution: $$ \rho=\sum_{\alpha=1}^4 g_{\alpha} $$
$$ \rho u_x=\sum_{\alpha=1}^4 c_{\alpha,x}g_{\alpha} $$$$ \rho u_y=\sum_{\alpha=1}^4 c_{\alpha,y}g_{\alpha} $$La distance entre les franges d'interférences appellé interfrange est donnée par: $$ i=\frac{\lambda D}{d} $$
avec $\lambda$: longueur d'onde de la source, $D$:distance d'observation et $d$: distance entre les fentes.
Pour reproduire les données expérimentales, on représente souvent l'intensit\'e acoustique $$ I=\frac{p'^2}{\rho_0c_0} $$
sur une ligne située à une distance $D$ des fentes.
Pour les paramètres du calcul, on choisira les valeurs suivantes:
ainsi que les paramètres du modèle D2Q4 décrits plus haut.
Completer les cellules suivantes pour pouvoir effectuer ce calcul.
#Import des modules utiles
import numpy as np
import matplotlib.pyplot as plt
import time
#Pour pouvoir afficher les figures dans le Notebook
%matplotlib inline
# Parametres du modele D2Q4
c0=...
tau=...
#Nombre de points
nx,ny,nt=...
#source
source=... #Position de la source
freq=... #frequence normalisee de la source
#Parois (obstacle=1 si paroi, et 0 sinon)
obstacle=np.zeros((nx,ny))
... # Ligne complete suivant y
... # premiere fente
... # deuxieme fente
#Initialisation a zero
g1=np.zeros((nx,ny))
g2=np.zeros((nx,ny))
g3=np.zeros((nx,ny))
g4=np.zeros((nx,ny))
g1_coll=np.zeros((nx,ny))
g2_coll=np.zeros((nx,ny))
g3_coll=np.zeros((nx,ny))
g4_coll=np.zeros((nx,ny))
rho=np.zeros((nx,ny))
ux=np.zeros((nx,ny))
Iac=np.zeros((nt,ny))
Dans le cas des modèles linéaires comme le D2Q4, on peut remarquer que la fonction d'équilibre s'exprime linéairement en fonction des fonctions de distribution. Ainsi l'étape de collision peut se simplifier pour aboutir à une combinaison linéaire des $g_\alpha$. Cette simplification permet de ne pas utiliser de variables supplémentaires pour la fonction d'équilibre et peut présenter des avantages en terme de mémoire.
Après calcul et simplification, écrire la forme simplifiée de l'étape de collision et compléter les cellules suivantes. (On pourra utiliser des équations $latex$ dans le Notebook pour écrire la collision simplifiée).
Pour prendre en compte la source acoustique dans la simulation, on fait l'hypothèse suivante: $g_\alpha(x_s,y_s)=g_\alpha^{eq}(x_s,y_s)=\omega_\alpha \rho_s$
Cela revient donc à considérer que $u(x_s,y_s)=0$.
Pour ce TP, on traitera les conditions aux limites en imposant un gradient nul pour les fonctions de distribution: $$ \dfrac{\partial g_\beta}{\partial n}=0 $$ avec $\beta=\alpha;\mathbf{c}_\alpha .{n}=1$ où $n$ est la normale à la frontière du domaine. On aura donc: $$ g_\beta(0,:)=g_\beta(1,:) $$
#Boucle temporelle
start=time.time()
for t in range(nt):
# source
g1[source]=...
g2[source]=...
g3[source]=...
g4[source]=...
## Collision
g1_coll[obstacle==0]=...
g2_coll[obstacle==0]=...
g3_coll[obstacle==0]=...
g4_coll[obstacle==0]=...
## si obstacle : Condition aux limites solide
g1_coll[obstacle==1]=...
g2_coll[obstacle==1]=...
g3_coll[obstacle==1]=...
g4_coll[obstacle==1]=...
## Propagation
g1[1:-1,:]=...
g2[:,1:-1]=...
g3[0:-2,:]=...
g4[:,0:-2]=...
## Conditions aux bords:
g1[0,:]=...
g2[:,0]=...
g3[-1,:]=...
g4[:,-1]=...
# Calcul du moment d'ordre 1
rho=...
# Calcul de l'intensite acoustique sur la ligne d'observation:
Iac[t,:]=...
print time.time()-start
Représenter le champ de pression acoustique dans le domaine de calcul et décrire les résultats obtenus.
#Affichage du resultat
fig=plt.figure(1,figsize=(5,5))
plt.pcolormesh(rho.T)
Représenter le profil de l'intensité acoustique sur la ligne d'observation.
#Affichage du profil de l'intensité acoustique sur l'écran:
fig = plt.figure();
A partir de la figure précédente, calculer l'interfrange et le comparer à sa valeur théorique donnée plus haut.
from IPython.core.display import HTML
style=open('notebooks.css', "r").read()
HTML(style)