17. Interférences à deux ondes en optique.

CODE :

In [1]:

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit,leastsq
import numpy.random as npr
#%matplotlib qt

In [2]:

# Definition de la fonction affine
def f_aff(x, a, b):
    return a*x+b

# Montecarlo
def montecarlo(X, Y, uX, uY, N_mc=100, color1='r', color2='b', mini=None, maxi=None):
    
    sigma_X = uX*np.ones(X.size)
    sigma_Y = uY*np.ones(Y.size)

    param = np.zeros((2,N_mc))
    for i in range(N_mc):
        x_mc = npr.normal(loc=X, scale=sigma_X)
        y_mc = npr.normal(loc=Y, scale=sigma_Y)
        pop, pcov = curve_fit(f_aff, x_mc, y_mc)
        param[0,i] = pop[0]
        param[1,i] = pop[1]
        
    mini = mini if mini else X.min()
    maxi = maxi if maxi else X.max()
    x_th = np.linspace(mini, maxi, 4)
    y_th = f_aff(x_th, *pop)
    for i in range(N_mc):
        y_th = f_aff(x_th, *param[:,i])
        #plt.plot(x_th, y_th, color2, alpha=0.05)
    plt.errorbar(X, Y, xerr=uX, yerr=uY, fmt='+', capsize=2, color=color1,label="Mesures")
    # plt.show()

    a_moy = np.mean(param[0,:])
    b_moy = np.mean(param[1,:])
   # print("La pente moyenne sur les ", N_mc, "mesures est de :", np.round(a_moy,4))
    a_sig = np.std(param[0,:]) #ecart type
    
    x = np.linspace(0.8*min(X),max(X)*1.1,100)
    plt.plot(x,f_aff(x,a_moy,b_moy),'b--',label='Ajustement')
    #print("L'écart type entre les pentes des", N_mc, "mesures est de :", np.round(a_sig,4))
    #print("Le résultat est donc de :", f"a = {a_moy:.3f} +/- {a_sig:.3f}")
    #print("Cela correspond à une erreur de:", f"a_rel = {a_sig/a_moy*100:.0f} %")
    return (a_moy, a_sig)

In [3]:

def red(x): # intensité de la couleur rouge correspondant à cette longueur d'onde [0;1].
    return np.exp(-((x-630)**2)/8000)

def green(x): # intensité de la couleur verte correspondant à cette longueur d'onde [0;1].
    return np.exp(-((x-570)**2)/8000)

def blue(x): # intensité de la couleur bleue correspondant à cette longueur d'onde [0;1].
    return np.exp(-((x-450)**2)/7000)

def color(lambd): # code couleur RGB correspondant à la longueur d'onde.
    return (red(lambd), green(lambd), blue(lambd))

Interférences pour 2 sources ponctuelles incohérentes¶

In [4]:

Eps0 = 1
Lambda = 800

def Eps(x):
    return 2*Eps0*(1+np.cos(x))

a = 10

x = np.linspace(-7*np.pi, 7*np.pi, 1000)

v = 10

# Source 1 centrée
interf = np.zeros((100, 1000, 3))
interf[:, :, 0] = color(Lambda)[0]*Eps(x)*v
interf[:, :, 1] = color(Lambda)[1]*Eps(x)*v
interf[:, :, 2] = color(Lambda)[2]*Eps(x)*v

# Source 2 décalée par rapport à  de a
interf_ = np.zeros((100, 1000, 3))
interf_[:, :, 0] = color(Lambda)[0]*Eps(x+a)*v
interf_[:, :, 1] = color(Lambda)[1]*Eps(x+a)*v
interf_[:, :, 2] = color(Lambda)[2]*Eps(x+a)*v

# Somme des sources 1 et 2
interf_tot = np.zeros((100, 1000, 3))
interf_tot[:, :, 0] = color(Lambda)[0]*(Eps(x)+Eps(x+a))*v
interf_tot[:, :, 1] = color(Lambda)[1]*(Eps(x)+Eps(x+a))*v
interf_tot[:, :, 2] = color(Lambda)[2]*(Eps(x)+Eps(x+a))*v

# Affichage
fig, ((ax1, ax2), (ax3, ax4), (ax5, ax6)) = plt.subplots(3,2, figsize = (13,6))    
ax1.imshow(interf)
ax1.axis('off')
ax2.plot(x,Eps(x))
ax2.set_xticks([-6*np.pi, -4*np.pi, -2*np.pi, 0, 2*np.pi, 4*np.pi, 6*np.pi], [r'$-4\pi$', r'$-2\pi$', r'$-\pi$', r'$0$', r'$2\pi$', r'$4\pi$', r'$6\pi$'])
ax2.set_ylim(-0.5,5.5)
ax3.imshow(interf_)
ax3.axis('off')
ax4.plot(x,Eps(x+a))
ax4.set_xticks([-6*np.pi, -4*np.pi, -2*np.pi, 0, 2*np.pi, 4*np.pi, 6*np.pi], [r'$-4\pi$', r'$-2\pi$', r'$-\pi$', r'$0$', r'$2\pi$', r'$4\pi$', r'$6\pi$'])
ax4.set_ylim(-0.5,5.5)
ax5.imshow(interf_tot)
ax5.axis('off')
ax6.plot(x,Eps(x)+Eps(x+a))
ax6.set_xticks([-6*np.pi, -4*np.pi, -2*np.pi, 0, 2*np.pi, 4*np.pi, 6*np.pi], [r'$-4\pi$', r'$-2\pi$', r'$-\pi$', r'$0$', r'$2\pi$', r'$4\pi$', r'$6\pi$'])
ax6.set_ylim(-0.5,5.5)
plt.xlabel('Δφ')
plt.ylabel('Eclairement [W/m²]')
fig.tight_layout()

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

Interférences pour un doublet de longueur d'onde¶

In [5]:

Eps0 = 1
D = 1
a = 430e-6
Lambda1 = 420
Lambda2 = 380

def Eps(x,Lambda):
    return 2*Eps0*(1+np.cos((2*np.pi*a*x)/(Lambda*1e-9*D)))

x = np.linspace(-10e-3,10e-3, 1000)

w = 0.7

# Source 1 centrée
interf1 = np.zeros((100, 1000, 3))
interf1[:, :, 0] = color(Lambda1)[0]*Eps(x,Lambda1)*w
interf1[:, :, 1] = color(Lambda1)[1]*Eps(x,Lambda1)*w
interf1[:, :, 2] = color(Lambda1)[2]*Eps(x,Lambda1)*w

# Source 2 décalée par rapport à  de a
interf2 = np.zeros((100, 1000, 3))
interf2[:, :, 0] = color(Lambda2)[0]*Eps(x,Lambda2)*w
interf2[:, :, 1] = color(Lambda2)[1]*Eps(x,Lambda2)*w
interf2[:, :, 2] = color(Lambda2)[2]*Eps(x,Lambda2)*w

# Somme des sources 1 et 2
interf_tot = np.zeros((100, 1000, 3))
interf_tot[:, :, 0] = (color(Lambda1)[0]*Eps(x,Lambda1))+(color(Lambda2)[0]*Eps(x,Lambda2))*w
interf_tot[:, :, 1] = (color(Lambda1)[1]*Eps(x,Lambda1))+(color(Lambda2)[1]*Eps(x,Lambda2))*w
interf_tot[:, :, 2] = (color(Lambda1)[2]*Eps(x,Lambda1))+(color(Lambda2)[2]*Eps(x,Lambda2))*w


# Affichage
fig, ((ax1, ax2), (ax3, ax4), (ax5, ax6)) = plt.subplots(3,2, figsize = (13,6))    
ax1.imshow(interf1)
ax1.axis('off')
ax2.plot(x,Eps(x,Lambda1))
ax2.set_ylim(-0.5,8.5)
ax3.imshow(interf2)
ax3.axis('off')
ax4.plot(x,Eps(x,Lambda2))
ax4.set_ylim(-0.5,8.5)
ax5.imshow(interf_tot)
ax5.axis('off')
ax6.plot(x,Eps(x,Lambda1)+Eps(x,Lambda2))
ax6.set_ylim(-0.5,8.5)
plt.xlabel('x')
plt.ylabel('Eclairement [W/m²]')
fig.tight_layout()

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).
Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

Eclairage en lumière blanche : Teintes de Newton¶

In [6]:

Eps0 = 1
D = 1
a = 430e-6
lambd = np.linspace(400, 800, 400) # liste des longueurs d'onde

def Eps(x,Lambda):
    return 2*Eps0*(1+np.cos((2*np.pi*a*x)/(Lambda*1e-9*D)))

x = np.linspace(-5e-3,5e-3, 1000)
s = 0.0015

interf = np.zeros((100, 1000, 3)) 
for i in range(400): #on parcourt toutes les longueurs d'ondes
    interf[:, :, 0] += color(lambd[i])[0]*Eps(x, lambd[i])*s #on ajoute à l'image précédente la composante rouge d'une image normalisée de la figure d'interférence à la longueur d'onde l
    interf[:, :, 1] += color(lambd[i])[1]*Eps(x, lambd[i])*s #on ajoute à l'image précédente la composante verte d'une image normalisée de la figure d'interférence à la longueur d'onde l
    interf[:, :, 2] += color(lambd[i])[2]*Eps(x, lambd[i])*s #on ajoute à l'image précédente la composante bleue d'une image normalisée de la figure d'interférence à la longueur d'onde l

fig, (ax1, ax2) = plt.subplots(2,1, figsize = (10,4))    
ax1.imshow(interf) #affichage de l'image correspondant à la figure d'interference
ax1.axis('off')
n=4 #choix du nombre de courbes à afficher
for i in range(n): #affichage des courbes d'intensité des différentes longueurs d'onde
    ax2.plot(x, Eps(x, lambd[i*400//n]), color = color(lambd[i*400//n]))
    ax2.set_xlabel("x")
    ax2.set_ylabel("Eclairement [W/m²]")

Expérience des fentes d'Young¶

In [7]:

# Mesure en direct
nbr_i = 

m = 
Dm = 

# Préparation
i = np.array([,m])*1e-2/nbr_i
ui = 0.5e-3/5 # on divise par 5 car on a mesure 5 i et on considère qu'on est précis à 0.5mm pour la mesure de l'ensemble des franges
D = np.array([,Dm])*1e-2
uD = 1e-3
Lambda = 635e-9

plt.figure(figsize = (8,5))
a_moy, a_sig = montecarlo(D, i, uD , ui, color1='red', color2='blue')
plt.plot(D[-1],i[-1],"og", markersize = 8, label = 'Point pris en direct')
plt.xlabel('Distance fentes-écran D [m]')
plt.ylabel('Interfrange i [m]')
plt.legend()
plt.show()

In [8]:

a = Lambda/a_moy
ua = a*a_sig/a_moy

print('L espace entre les  fentes est a_exp = (',round(a*1e6),'+/-', round(ua*1e6),') μm')
print(' Espace tabulé a_tab = 200 μm')

L espace entre les  fentes est a_exp = ( 205 +/- 7 ) μm
 Espace tabulé a_tab = 200 μm

Notion de cohérence spatiale¶

In [9]:

# Préparation
offset =  #m 
b = (np.array([])-offset)*1e-5 #mm
Emax = np.array([])
Emin = np.array([])
C = (Emax-Emin)/(Emax+Emin)

# Mesure en direct
bm = (-offset)*1e-5
Emaxm = 35.6
Eminm = 6.1
Cm = (Emaxm-Eminm)/(Emaxm+Eminm)

# Modèle
d = 45e-2 #m
a = 200e-6
lamb = 546e-9
b_th = np.linspace(0,0.005,100)
def C_th(b_th):
    u = np.pi*a*b_th/(lamb*d)
    return np.sin(u)/u

plt.figure(figsize = (10,6))
plt.plot(b,C,'+',label='Points expérimentaux')
plt.plot(bm,Cm,"og", markersize = 10, label = 'Point pris en direct')
plt.plot(b_th,0*b_th,'k', label = 'Droite y=0')
plt.plot(b_th,C_th(b_th), label = 'Courbe théorique')
plt.xlabel('Largeur de la fente b [m]')
plt.ylabel('Visibilité')
plt.legend()
plt.show()

C:\Users\Galy_\AppData\Local\Temp\ipykernel_12252\96332154.py:21: RuntimeWarning: invalid value encountered in divide
  return np.sin(u)/u

In [ ]:

Date de dernière mise à jour : 07/06/2025