M31 : Résonance¶
Ugo Hincelin, Novembre 2016
Objectifs :¶
- Illustrer le phénomène de résonance dans différents domaines de la physique (ici, en mécanique et en électronique)
Intérêts :¶
- Dans chaque domaine, on voit que la résonance peut être utilisée pour mesurer des paramètres du système : la vitesse de propagation d'une onde dans une corde, la masse linéique d'une corde, la vitesse du son dans l'air, la longueur caractéristique intervenant dans une résonance acoustique.
- On évoque aussi les applications : balançoire, filtre RLC pour fabriquer une radio, instruments de musique et les problèmes que l'on peut rencontrer : tremblement de terre et pont.
0. Définition¶
On mesure une grandeur physique. On voit qu'elle présente une amplitude maximale pour une ou plusieurs fréquences particulières. On parle alors de résonance. Attention : le déphasage entre une excitation et la variation de la grandeur physique n'est pas toujours nul, donc la résonance ne peut pas être définie de la sorte. Exemple : résonance en tension aux bornes d'un condensateur ou d'une bobine pour un facteur de qualité faible déphasé par rapport à la tension du générateur.
I. Vibration d'une corde¶
Nous allons déduire de cette expérience la vitesse de propagation des ondes dans la corde, et la masse linéique de la corde. Ce montage permet donc de construire une balance qui utilise le phénomène de résonance.
I.1. Description rapide du setup¶
Corde de Melde : GBF (Amplitude de 10 ou 20 Volt pour bien voir les vibrations), Générateur de vibration, corde (78 cm), poulie, masse (25 g)
I.2. Théorie¶
Modes propres associés au phénomène de résonance en régime forcé : $y_{n}(t)=\frac{a}{\sin kL}\cos(\omega_{n}t)\sin(\frac{\omega_{n}(L-x)}{c})$. L'amplitude est maximale pour $L=\frac{n\lambda}{2}$
- Montrer expérimentalement qu'il existe des fréquences particulières pour lesquelles on a une amplitude de vibration maximale.
I.3. Mesure de la vitesse de propagation de l'onde¶
- Je cherche les fréquences $f$ pour lesquelles j'ai une amplitude maximale.
- Je note les valeurs de $f$ et je mesure $\lambda /2$.
- Suggestion : faire un tableau (au tableau) avec en colonnes n, $\lambda$ et f et noter les mesures.
- Je trace $f$ en fonction de $1/\lambda$ ($v = \lambda f$ donc $f = v \frac{1}{\lambda}$).
- Régression linéaire, le coefficient directeur me donne la vitesse.
- Le code python ci-dessous fait ce travail, en se basant sur les données contenues dans le fichier "corde_melde.txt" (colonne 1 : $\lambda/2$ ; colonne 2 : $\Delta \lambda/2$ ; colonne 3 : $f$ ; colonne 4 : $\Delta f$. Expliquer les grandes lignes du code à l'oral.
In [3]:
%matplotlib inline
import numpy as np
import pylab as plt
from scipy.optimize import curve_fit
m = 25e-3 # kg, masse suspendu à la corde
Deltam = 1e-3 # kg, incertitude sur cette masse
g = 9.81 # m.s^-2, accélération de la pesanteur
T = m*g # tension appliquée au fil
DeltaT = g*Deltam # incertitude sur la tension
## Lecture des données
# ouverture du fichier de données
file = open("corde_melde.txt", 'r')
# skip firt two lines
file.readline()
file.readline()
# création des tableaux
L_tab = np.array([])
DeltaL_tab = np.array([])
F_tab = np.array([])
DeltaF_tab = np.array([])
# lit les données puis attribue l'info aux variables
for ligne in file:
mots = ligne.split()
L = float(mots[0])
DeltaL = float(mots[1])
F = float(mots[2])
DeltaF = float(mots[3])
L_tab = np.append(L_tab,L)
DeltaL_tab = np.append(DeltaL_tab,DeltaL)
F_tab = np.append(F_tab,F)
DeltaF_tab = np.append(DeltaF_tab,DeltaF)
L_tab = 2*(L_tab)*1e-3 # lambda/2 mm en lambda m
DeltaL_tab = 2*DeltaL_tab*1e-3 # mm en m
X_tab = 1/L_tab
Y_tab = F_tab # fréquence
print(X_tab,Y_tab)
# Définition de l'erreur sur les points expérimentaux
errX_tab = DeltaL_tab/L_tab**2
errY_tab = DeltaF_tab
print(errX_tab,errY_tab)
# Définition de la fonction pour le calcul du chi^2 et du chi_réduit^2
# Bally, Berroir 2008, Incertitudes expérimentales
# chi_reduit^2 ~ 1 : bon accord avec le modèle
# chi_reduit^2 >> 1 : modèle non validé
# chi_reduit^2 << 1 : incertitudes surestimées ?
def chi2(sigma_exp,y_th,y_exp,nb_param):
chi2 = sum(((y_th - y_exp)/sigma_exp)**2)
nDOF = len(y_exp) - nb_param
chi_red_2 = chi2/(nDOF)
return chi2,chi_red_2
## Régression linéaire sur Y=f(t)
print('### Régression linéaire ###')
def flin(x,a,b):
return a*x+b
p, covm = curve_fit(flin,X_tab,Y_tab)
a,b = p
# Compute chi2
chi2_lin,chi_red_2_lin = chi2(errY_tab,flin(X_tab,a,b),Y_tab,2)
# Correction des barres d'erreur (kesako? à voir...)
erra, errb = np.sqrt(np.diag(covm)/chi_red_2_lin)
# Print des résultats
print("pente = %.1e +/- %.1e" %(a, erra))
print("ordonnée origine = %.1e +/- %.1e" %(b, errb))
print("chi2 = %.2f" % chi2_lin)
print("chi_red_2 = %.3f" % chi_red_2_lin)
## Figure
fig, ax = plt.subplots(1)
ax.errorbar(X_tab,Y_tab,errY_tab,errX_tab,fmt='.')
X_fit = np.linspace(X_tab[0]-(X_tab[-1]-X_tab[0])/50., X_tab[-1]+(X_tab[-1]-X_tab[0])/50., 100)
Y_fit = flin(X_fit,a,b)
ax.plot(X_fit,Y_fit,label="ajustement")
textstr = "y(x) = a*x + b\n\
a = %.2e +/- %.1e \n\
b = %.1e +/- %.1e \n\
chi_red_2 = %.2f" %(a,erra,b,errb,chi_red_2_lin)
ax.text(0.05, 0.95, textstr,transform=ax.transAxes, fontsize=12, verticalalignment='top')
ax.legend(loc=8)
plt.xlabel("$1/\lambda \, (m^{-1})$", fontsize=16)
plt.ylabel("$f \, (Hz)$", fontsize=16)
plt.show()
On obtient $v = 22.6\pm 0.2$ m.s$^{-1}$. C'est la vitesse des ondes progressives, qui par addition forment l'onde stationnaire.
I.4. Mesure de la masse linéique de la corde¶
- Avec les mesures précédentes, on peut tracer $\frac{mg}{f²} = \mu \lambda^2$ et le coefficient directeur de la droite obtenue par régression linéaire nous donne la masse linéique. Remarque : cette étape n'est pas indispensable, connaissant $v$ à partir de la section I.3. et la relation $v = \sqrt(\frac{mg}{\mu})$ on peut directement calculer la masse linéique.
- Le code python ci-dessous fait la régression linéaire.
In [2]:
%matplotlib inline
import numpy as np
import pylab as plt
from scipy.optimize import curve_fit
m = 25e-3 # kg, masse suspendu à la corde
Deltam = 1e-3
g = 9.81 # m.s^-2, accélération de la pesanteur
T = m*g
DeltaT = g*Deltam
## Lecture des données
# ouverture du fichier de données
file = open("corde_melde.txt", 'r')
# skip firt two lines
file.readline()
file.readline()
# création des tableaux
L_tab = np.array([])
DeltaL_tab = np.array([])
F_tab = np.array([])
DeltaF_tab = np.array([])
# lit les données puis attribue l'info aux variables
for ligne in file:
mots = ligne.split()
L = float(mots[0])
DeltaL = float(mots[1])
F = float(mots[2])
DeltaF = float(mots[3])
L_tab = np.append(L_tab,L)
DeltaL_tab = np.append(DeltaL_tab,DeltaL)
F_tab = np.append(F_tab,F)
DeltaF_tab = np.append(DeltaF_tab,DeltaF)
L_tab = 2*(L_tab)*1e-3 # lambda/2 mm en lambda m
DeltaL_tab = 2*DeltaL_tab*1e-3 # mm en m
#DeltaF_tab = DeltaF_tab*2
#DeltaL_tab = DeltaL_tab*2
X_tab = (L_tab)**2 # longueur d'onde au carré
Y_tab = T/F_tab**2 # tension sur fréquence²
print(X_tab,Y_tab)
# Définition de l'erreur sur les points expérimentaux
errX_tab = 2*L_tab*DeltaL_tab
errY_tab = np.sqrt((T*DeltaF_tab*2/F_tab**3)**2 + (DeltaT/F_tab**2)**2)
print(errX_tab,errY_tab)
# Définition de la fonction pour le calcul du chi^2 et du chi_réduit^2
# Bally, Berroir 2008, Incertitudes expérimentales
# chi_reduit^2 ~ 1 : bon accord avec le modèle
# chi_reduit^2 >> 1 : modèle non validé
# chi_reduit^2 << 1 : incertitudes surestimées ?
def chi2(sigma_exp,y_th,y_exp,nb_param):
chi2 = sum(((y_th - y_exp)/sigma_exp)**2)
nDOF = len(y_exp) - nb_param
chi_red_2 = chi2/(nDOF)
return chi2,chi_red_2
## Régression linéaire sur Y=f(t)
print('### Régression linéaire ###')
def flin(x,a,b):
return a*x+b
p, covm = curve_fit(flin,X_tab,Y_tab)
a,b = p
# Compute chi2
chi2_lin,chi_red_2_lin = chi2(errY_tab,flin(X_tab,a,b),Y_tab,2)
# Correction des barres d'erreur (kesako? à voir...)
erra, errb = np.sqrt(np.diag(covm)/chi_red_2_lin)
# Print des résultats
print("pente = %.1e +/- %.1e" %(a, erra))
print("ordonnée origine = %.1e +/- %.1e" %(b, errb))
print("chi2 = %.2f" % chi2_lin)
print("chi_red_2 = %.3f" % chi_red_2_lin)
## Figure 1 : Trace Fréquence en fonction de 1/lambda avec l'ajustement et les paramètres
fig, ax = plt.subplots(1)
ax.errorbar(X_tab,Y_tab,errY_tab,errX_tab,fmt='.')
X_fit = np.linspace(X_tab[0]-(X_tab[-1]-X_tab[0])/50., X_tab[-1]+(X_tab[-1]-X_tab[0])/50., 100)
Y_fit = flin(X_fit,a,b)
ax.plot(X_fit,Y_fit,label="ajustement")
textstr = "y(x) = a*x + b\n\
a = %.2e +/- %.1e \n\
b = %.1e +/- %.1e \n\
chi_red_2 = %.2f" %(a,erra,b,errb,chi_red_2_lin)
ax.text(0.05, 0.95, textstr,transform=ax.transAxes, fontsize=12, verticalalignment='top')
ax.legend(loc=8)
plt.xlabel("$\lambda^2 \, (m^{2})$", fontsize=16)
plt.ylabel("$T/f^2 \, (N.s^{-2})$", fontsize=16)
plt.show()
On obtient $\mu = 0.56 \pm 0.01$ g.m$^{-1}$. Nous avons fabriqué une balance qui utilise la phénomène de résonance. Je compare avec une balance électronique la masse de 2 m de corde, et j'obtiens $1.1 \pm 0.1$ g. Remarque : j'ai une meilleure précision avec ma balance.
- Suggestion : faire des mesures différentes que la partie précédente. On varie la masse $m$ donc on varie $T=mg$ et on mesure $f$ afin de retrouver la résonance. Ainsi, on aura comme variable $m$ et $f$, puisque $n\lambda/2$ sera fixe, égale à la longueur de la corde. Attention, bien veiller à faire les mesures avec le même mode de vibration (exemple : n = 2 pour toutes les mesures). On peut alors tracer la même fonction, $\frac{mg}{f²} = \mu \lambda^2$ et faire une régression linéaire pour extraire $\mu$.
II. Circuit RLC série¶
Nous allons montrer qu'il existe des fréquences du signal d'entrée pour lesquelles nous obtenons un maximum en intensité ou en tension. Les fréquences vont être dépendantes du composant étudié (résistor, condensateur ou bobine). On contextualise en parlant du récepteur radio.
II.1. Description rapide du setup¶
- Boîtes à décade pour faire varier résistance, capacité et inductance.
- GBF
- Oscilloscope
- Générateur +15/-15V, Amplificateur Opérationnel et Platine pour monter un suiveur
- Valeur de départ : $100 \Omega$, $0.1 \mu$F, $16$ mH.
II.2. Théorie associée¶
- E : Tension délivrée par le GBF ; R$_t$ : résistance totale du circuit (générateur r, bobine rb, résistor R) ; L : inductance ; C : capacité ; R : résistance du résistor ; $\omega = 2\pi f$ : pulsation
- Modèle de Thévenin du GBF : U = E - rI
- Modèle de Thévenin du GBF + suiveur : U = E. A la résonance en intensité, lorsque I est maximal, la tension aux bornes du GBF ne chute plus. Le montage suiveur est donc important pour l'étude de la résonance.
- Intensité $I(\omega) = \frac{E}{\sqrt{R^2+(L\omega - \frac{1}{C\omega})^2}}$
- Pulsation de résonance $\omega_0 = \frac{1}{\sqrt{LC}}$
- Facteur de qualité : $Q = \frac{1}{R}\sqrt{\frac{L}{C}}$
- Tension aux bornes du condensateur : $U_C = \frac{E}{\sqrt{(1-LC\omega^2)^2+(RC\omega)^2}}$
- Pulsation de résonance en tension pour le condensateur : $\omega_C = \omega_0 \sqrt{1-\frac{1}{2Q^2}}$. Cette résonance n'existe que si $Q \geq \frac{1}{\sqrt{2}}$. Q ne doit pas être trop grand pour voir la différence entre les deux pulsations $\omega_0$ et $\omega_C$.
- Le code python qui suit permet de calculer les fréquences de résonance en fonction de R, L et C.
In [2]:
import numpy as np
L = 16e-3
C = 100e-9
R = 100
print("L =",L)
print("C =",C)
print("R =",R)
# Facteur de qualité
Q = 1/R*np.sqrt(L/C)
print("Q =",Q)
print("1/sqrt(2)=",1/np.sqrt(2))
# Fréquence résonance théorique tension résistor
omega0 = 1/np.sqrt(L*C)
print("fréquence (résistor) :",omega0/(2*np.pi),"Hz")
# Fréquence résonance théorique tension condensateur
omegaC = omega0*np.sqrt(1-1/(2*Q**2))
print("fréquence (condensateur) :",omegaC/(2*np.pi),"Hz")
# Fréquence résonance théorique tension bobine
omegaL = omega0/np.sqrt(1-1/(2*Q**2))
print("fréquence (bobine) :",omegaL/(2*np.pi),"Hz")
II.3. Mesure de I en fonction de f¶
- Le montage est le suivant :
- On repère la fréquence de résonance. On peut ensuite faire un "sweep" avec le GBF entre +/- quelques kHz pour voir plusieurs fois l'évolution de la tension en fonction de f sur l'écran de l'oscilloscope.
- On mesure $U_R$ en fonction de $f$.
- Sous python on trace I en fonction de f et on fait un ajustement.
- On peut utiliser le curseur pour repérer la valeur de la fréquence de résonance. Ensuite on va chercher les valeurs des fréquences de résonance pour lesquelles on a une intensité de $\frac{I}{\sqrt{2}}$ et on calcule le facteur de qualité.
- Le code python suivant montre l'intensité en fonction de la fréquence.
In [3]:
%matplotlib inline
import numpy as np
import pylab as plt
from scipy.optimize import curve_fit
R1 = 100 # Ohm
R2 = 500 # Ohm
R3 = 2000 # Ohm
DeltaU = 0.020 # V
DeltaF = 10 # Hz
## Lecture des données
# ouverture du fichier de données
file = open("RLC_resistor.txt", 'r')
# skip firt lines
file.readline()
file.readline()
# création des tableaux
F_tab = np.array([])
U1_tab = np.array([])
U2_tab = np.array([])
U3_tab = np.array([])
# lit les données puis attribue l'info aux variables
for ligne in file:
mots = ligne.split()
F = float(mots[0])
U1 = float(mots[1])
U2 = float(mots[2])
U3 = float(mots[3])
F_tab = np.append(F_tab,F)
U1_tab = np.append(U1_tab,U1)
U2_tab = np.append(U2_tab,U2)
U3_tab = np.append(U3_tab,U3)
F_tab = F_tab*1e3 # kHz en Hz
U1_tab = U1_tab*1e-3 # mV en V
U2_tab = U2_tab*1e-3 # mV en V
U3_tab = U3_tab*1e-3 # mV en V
X_tab = F_tab # fréquence
errX_tab = X_tab*0 + DeltaF
Y_tab = U1_tab/R1 # intensité en A
errY_tab = Y_tab*0 + DeltaU/R1
## Définition de la fonction pour le calcul du chi^2 et du chi_réduit^2
# Bally, Berroir 2008, Incertitudes expérimentales
# chi_reduit^2 ~ 1 : bon accord avec le modèle
# chi_reduit^2 >> 1 : modèle non validé
# chi_reduit^2 << 1 : incertitudes surestimées ?
def chi2(sigma_exp,y_th,y_exp,nb_param):
chi2 = sum(((y_th - y_exp)/sigma_exp)**2)
nDOF = len(y_exp) - nb_param
chi_red_2 = chi2/(nDOF)
return chi2,chi_red_2
print("### Régression non linéaire ###")
def fnc_nonlin(x, A, B, C, D):
return A/np.sqrt(B**2+(C*2*np.pi*x-1/(D*x*2*np.pi))**2)
# en option, valeur des paramètres de départ
param = [1,100,16e-3,100e-9]
popt, pcov = curve_fit(fnc_nonlin, X_tab, Y_tab, param)
A_op, B_op, C_op, D_op = popt
# Compute chi2
chi2_nlin,chi_red_2_nlin = chi2(errY_tab,fnc_nonlin(X_tab,A_op,B_op,C_op,D_op),Y_tab,4)
# Correction des barres d'erreur (kesako? à voir...)
errA_op, errB_op, errC_op, errD_op = np.sqrt(np.diag(pcov)/chi_red_2_nlin)
# Tell me the results baby !
print("A/np.sqrt(B**2+(C*2*np.pi*x-1/(D*x*2*np.pi))**2)")
print("A=%.3e +/- %.3E, B=%.3E +/- %.3e, C=%.3e +/- %.3e, D=%.3e +/- %.3e " %(A_op,errA_op,B_op,errB_op,C_op,errC_op,D_op,errD_op))
print("chi2 = %.2f" % chi2_nlin)
print("chi_red_2 = %.3f" % chi_red_2_nlin)
print("###")
## Figure
fig, ax = plt.subplots(1)
ax.errorbar(X_tab,Y_tab,errY_tab,errX_tab,fmt='.',label="données exp.")
X_fit = np.linspace(X_tab[0], X_tab[-1], 500)
Y_fit = fnc_nonlin(X_fit, A_op, B_op, C_op, D_op)
ax.plot(X_fit,Y_fit,label="ajustement")
plt.xlabel("$fréquence (Hz)$", fontsize=16)
plt.ylabel("$intensité (A)$", fontsize=16)
plt.show()
II.4. Mesure de $U_C$ en fonction de f¶
- On réalise le montage suivant (condensateur et résistor sont échangés afin de définir les masses correctement) :
- On réalise les mêmes mesures et on trace $U_C$ en fonction de $f$. On remarque que la résonance n'a pas lieu pour la même fréquence que précedemment.
- Code python :
In [5]:
%matplotlib inline
import numpy as np
import pylab as plt
from scipy.optimize import curve_fit
R1 = 100 # Ohm
R2 = 500 # Ohm
DeltaU = 0.020 # V
DeltaF = 10 # Hz
## Lecture des données
# ouverture du fichier de données
file = open("RLC_condensateur.txt", 'r')
# skip firt lines
file.readline()
file.readline()
# création des tableaux
F_tab = np.array([])
U1_tab = np.array([])
U2_tab = np.array([])
# lit les données puis attribue l'info aux variables
for ligne in file:
mots = ligne.split()
F = float(mots[0])
U1 = float(mots[1])
U2 = float(mots[2])
F_tab = np.append(F_tab,F)
U1_tab = np.append(U1_tab,U1)
U2_tab = np.append(U2_tab,U2)
F_tab = F_tab*1e3 # kHz en Hz
X_tab = F_tab # fréquence
errX_tab = X_tab*0 + DeltaF
Y_tab = U1_tab # tension
errY_tab = Y_tab*0 + DeltaU
## Définition de la fonction pour le calcul du chi^2 et du chi_réduit^2
# Bally, Berroir 2008, Incertitudes expérimentales
# chi_reduit^2 ~ 1 : bon accord avec le modèle
# chi_reduit^2 >> 1 : modèle non validé
# chi_reduit^2 << 1 : incertitudes surestimées ?
def chi2(sigma_exp,y_th,y_exp,nb_param):
chi2 = sum(((y_th - y_exp)/sigma_exp)**2)
nDOF = len(y_exp) - nb_param
chi_red_2 = chi2/(nDOF)
return chi2,chi_red_2
## Régression non linéaire (parabole) sur Z=f(Y)
print("### Régression non linéaire ###")
def fnc_nonlin(x, A, B, C, D):
return A/np.sqrt((1-C*D*x**2)**2+(B*D*x**2)**2)
# en option, valeur des paramètres de départ
param = [1,100,16e-3,100e-9]
popt, pcov = curve_fit(fnc_nonlin, X_tab, Y_tab, param)
A_op, B_op, C_op, D_op = popt
# Compute chi2
chi2_nlin,chi_red_2_nlin = chi2(errY_tab,fnc_nonlin(X_tab,A_op,B_op,C_op,D_op),Y_tab,4)
# Correction des barres d'erreur (kesako? à voir...)
errA_op, errB_op, errC_op, errD_op = np.sqrt(np.diag(pcov)/chi_red_2_nlin)
# Tell me the results baby !
print("A/np.sqrt(B**2+(C*2*np.pi*x-1/(D*x*2*np.pi))**2)")
print("A=%.3e +/- %.3E, B=%.3E +/- %.3e, C=%.3e +/- %.3e, D=%.3e +/- %.3e " %(A_op,errA_op,B_op,errB_op,C_op,errC_op,D_op,errD_op))
print("chi2 = %.2f" % chi2_nlin)
print("chi_red_2 = %.3f" % chi_red_2_nlin)
print("###")
## Figure
fig, ax = plt.subplots(1)
ax.errorbar(X_tab,Y_tab,errY_tab,errX_tab,fmt='.',label="données exp.")
X_fit = np.linspace(X_tab[0], X_tab[-1], 500)
Y_fit = fnc_nonlin(X_fit, A_op, B_op, C_op, D_op)
ax.plot(X_fit,Y_fit,label="ajustement")
plt.xlabel("$fréquence (Hz)$", fontsize=16)
plt.ylabel("$tension (V)$", fontsize=16)
plt.show()
II.5. Modèle du circuit RLC (plutôt pour une leçon pour illustrer)¶
- Montrer la variation du facteur de qualité en fonction de R.
- Montrer le balayage en fréquence pour une variation de C.
- Analogie avec la radio AM (Amplitude Modulation)
- Remarque : la radio FM (frequency modulation) fonctionne sur un principe différent. Le filtre est inchangé, mais le signal est décalé en fréquence.
- Code python de l'animation à utiliser avec pyzo pour avoir la main sur les barres de contrôle :
In [6]:
# -*- coding: utf-8 -*-
"""
Ugo Hincelin - Novembre 2016
Animation pour montrer l'influence des différents paramètres d'un circuit RLC série sur la bande passante.
En Y : intensité normalisée par Imax
En X : pulsation omega
"""
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider, Button, RadioButtons
eo = 5 # Volt
im = 1 # unité de io
fig, ax = plt.subplots()
plt.subplots_adjust(left=0.25, bottom=0.25)
omega = np.arange(1e3, 1e5, 1e1)
L0 = 16 # milli Henry
C0 = 0.1 # micro Farad
R0 = 100 # Ohm
Q0 = 1/R0*np.sqrt(L0*1E-3/(C0*1E-6))
print("Q0 =",Q0)
io = im/(np.sqrt(1+Q0**2*(omega/(1/np.sqrt(L0*1E-3*C0*1E-6))-1/np.sqrt(L0*1E-3*C0*1E-6)/omega)**2))
l, = plt.plot(omega, io, lw=2, color='red')
plt.axis([1000, 100000, 0, 1])
plt.xlabel("pulsation")
plt.ylabel("Io/Imax")
axcolor = 'lightgoldenrodyellow'
axL = plt.axes([0.25, 0.07, 0.65, 0.03], axisbg=axcolor)
axC = plt.axes([0.25, 0.12, 0.65, 0.03], axisbg=axcolor)
axR = plt.axes([0.25, 0.02, 0.65, 0.03], axisbg=axcolor)
ioL = Slider(axL, 'L (mH)', 10, 100, valinit=L0)
ioC = Slider(axC, 'C (microF)', 0.01, 0.2, valinit=C0)
ioR = Slider(axR,'R (ohm)',10,10000,valinit=R0)
def update(val):
L = ioL.val*1E-3
C = ioC.val*1E-6
R = ioR.val
omegaO = 1/np.sqrt(L*C)
Q = 1/R*np.sqrt(L/C)
l.set_ydata(im/(np.sqrt(1+Q**2*(omega/omegaO-omegaO/omega)**2)))
fig.canvas.draw_idle()
ioL.on_changed(update)
ioC.on_changed(update)
ioR.on_changed(update)
resetax = plt.axes([0.03, 0.07, 0.1, 0.04])
button = Button(resetax, 'Reset', color=axcolor, hovercolor='0.975')
def reset(event):
ioL.reset()
ioC.reset()
ioR.reset()
button.on_clicked(reset)
plt.show()
III. Instruments de musique¶
Nous allons illustrer le phénomène de résonance acoustique avec deux types d'instruments. On va pouvoir calculer la vitesse du son.
III.1. Instrument type clarinette¶
III.1.1. Description rapide du setup¶
- Tubes à essai rempli d'eau avec une variation de la hauteur d'eau.
- Porte tubes
- Electret
- Oscilloscope
Règle
On souffle sur l'ouverture du tube dans une direction environ orthogonale à celle-ci.
- On fait un arrêt sur image à l'oscilloscope pour analyser.
III.1.2. Théorie associée (succinte)¶
On génère une onde progressive qui se réfléchit sur la surface de l'eau. L'onde réfléchit se superpose à l'onde incidente, et crée une onde stationnaire. Il y a des interférences destructives entre les deux ondes progressives de sorte que les ondes stationnaires formées ont des fréquences particulières. Il y a deux conditions aux limites pour notre intrument : au fond du tube la pression acoustique est maximale, et au bord de l'ouverture du tube la pression acoustique est nulle car imposée par la pression atmosphérique. Par définition (selon les sources bibliographiques) la pression acoustique est la surpression par rapport à la pression de l'air. Donc pour une pression identique à celle de l'air, la pression acoustique est nulle. La longueur $h$ (voir ci dessous) est donc un multiple entier de $\lambda/4$ : $h = (2n+1) \frac{\lambda}{4}$.
$h$ est relié à la célérité et la fréquence du son émis par : $\lambda/4$ : $h = (2n+1) \frac{\lambda}{4} = (2n+1) \frac{c}{4 f_r}$. $f_r$ désigne la fréquence de résonance.
III.1.3. Mesure de la vitesse du son¶
On souffle dans le tube. On fait un arrêt sur image à l'oscilloscope. On mesure le temps sur 10 périodes ou bien on mesure directement $f_r$ avec la fonction Fourier pour les différents tubes (c'est-à-dire pour les différentes valeurs de $h$). On trace $f_r$ en fonction de $\frac{1}{\lambda}$. La pente de la droite d'ajustement donne la vitesse du son. Le code python ci-dessous fait ce travail à partir du fichier de données.
In [7]:
%matplotlib inline
import numpy as np
import pylab as plt
from scipy.optimize import curve_fit
## Lecture des données
# ouverture du fichier de données
file = open("tubes.txt", 'r')
# skip firt two lines
file.readline()
file.readline()
# création des tableaux
h_tab = np.array([])
Deltah_tab = np.array([])
dixT_tab = np.array([])
DeltadixT_tab = np.array([])
T_tab = np.array([])
DeltaT_tab = np.array([])
# lit les données puis attribue l'info aux variables
for ligne in file:
mots = ligne.split()
h = float(mots[0])
Deltah = float(mots[1])
dixT = float(mots[2])
DeltadixT = float(mots[3])
T = float(mots[4])
DeltaT = float(mots[5])
h_tab = np.append(h_tab,h)
Deltah_tab = np.append(Deltah_tab,Deltah)
T_tab = np.append(T_tab,T)
DeltaT_tab = np.append(DeltaT_tab,DeltaT)
h_tab = h_tab*1e-2 # cm en m
Deltah_tab = Deltah_tab*1e-2
T_tab = T_tab*1e-3 # ms en s
DeltaT_tab = DeltaT_tab*1e-3
X_tab = 1/(4*h_tab) # inverse de la longueur d'onde
Y_tab = 1/(T_tab) # fréquence
# Définition de l'erreur sur les points expérimentaux
errX_tab = Deltah_tab/(4*h_tab**2)
errY_tab = DeltaT_tab/T_tab**2
# Définition de la fonction pour le calcul du chi^2 et du chi_réduit^2
# Bally, Berroir 2008, Incertitudes expérimentales
# chi_reduit^2 ~ 1 : bon accord avec le modèle
# chi_reduit^2 >> 1 : modèle non validé
# chi_reduit^2 << 1 : incertitudes surestimées ?
def chi2(sigma_exp,y_th,y_exp,nb_param):
chi2 = sum(((y_th - y_exp)/sigma_exp)**2)
nDOF = len(y_exp) - nb_param
chi_red_2 = chi2/(nDOF)
return chi2,chi_red_2
## Régression linéaire sur Y=f(t)
print('### Régression linéaire ###')
def flin(x,a,b):
return a*x+b
p, covm = curve_fit(flin,X_tab,Y_tab)
a,b = p
# Compute chi2
chi2_lin,chi_red_2_lin = chi2(errY_tab,flin(X_tab,a,b),Y_tab,2)
# Correction des barres d'erreur (kesako? à voir...)
erra, errb = np.sqrt(np.diag(covm)/chi_red_2_lin)
# Print des résultats
print("pente = %.3f +/- %.3f" %(a, erra))
print("ordonnée origine = %.2f +/- %.2f" %(b, errb))
print("chi2 = %.2f" % chi2_lin)
print("chi_red_2 = %.3f" % chi_red_2_lin)
## Figure 1 : Trace Fréquence en fonction de 1/lambda avec l'ajustement et les paramètres
fig, ax = plt.subplots(1)
ax.errorbar(X_tab,Y_tab,errY_tab,errX_tab,fmt='.')
X_fit = np.linspace(X_tab[0]-(X_tab[-1]-X_tab[0])/50., X_tab[-1]+(X_tab[-1]-X_tab[0])/50., 100)
Y_fit = flin(X_fit,a,b)
ax.plot(X_fit,Y_fit,label="ajustement")
textstr = "y(x) = a*x + b\n\
a = %.2f +/- %.2f \n\
b = %.2f +/- %.2f \n\
chi_red_2 = %.2f" %(a,erra,b,errb,chi_red_2_lin)
ax.text(0.05, 0.95, textstr,transform=ax.transAxes, fontsize=12, verticalalignment='top')
ax.legend(loc=5)
plt.xlabel("$1/\lambda \, (m^{-1})$", fontsize=16)
plt.ylabel("$fréquence \, (Hz)$", fontsize=16)
plt.show()
La vitesse du son est de 371,9 +/- 8,6 m/s. La valeur est plus grande que celle attendue, 340. Une hypothèse sur ce décalage est que la pression acoustique n'est pas exactement minimale à l'ouverture du tube, donc on commet une erreur sur la longueur d'onde qui se répercute sur la vitesse du son.
III.1. Instrument type flûte traversière¶
Proposition de mesure pour remplacer la manip avec la flute à bec.
III.1.1. Description rapide du setup¶
- Tube type tube à poster
- Electret
- Oscilloscope
Règle
On claque des doigts sur une ouverture du tube. On mesure à l'electret le son émis sur l'autre ouverture du tube.
- On fait un arrêt sur image à l'oscilloscope pour analyser.
III.1.2. Théorie associée (succinte)¶
Comme précedemment, sauf qu'ici on change les conditions aux bords. La pression acoustique est nulle à chaque extrémité du tube. La longueur du tube est alors reliée à la longueur d'onde du son émis par $l = n \frac{\lambda}{2}$.
III.1.3. Mesure de la longueur du tube¶
Connaissant la vitesse du son dans l'air, 340 m/s, on remonte à la longueur du tube en traçant : $f_r \times l = c$, sachant que les fréquences mesurées sont $f_r = \frac{2 f}{n}$ où $n$ est le mode.
IV. Conclusion¶
Nous avons vu que dans chaque domaine, en électronique et en mécanique, la résonance peut être utilisée pour mesurer des paramètres du système : la vitesse de propagation d'une onde dans une corde, la masse linéique d'une corde, la vitesse du son dans l'air, ou bien la longueur caractéristique intervenant dans une résonance acoustique. C'est donc un phénomène intéressant à exploiter pour étudier un système dont certains paramètres inconnus sont à caractériser.
Bibliographie¶
JP Bellier, C Bouloy, D Guéant, Montages de physique - Electricité, électromagnétisme, électronique, acoustique, DUNOD
D Augier, C More, Compétences prépas Tec&Doc, Physique PCSI
In [ ]: