TP Introduction au monde quantique
Simulation d’interférences particule par particule.
Objectif : illustrer la dualité onde-corpuscule en réalisant une simulation d’interférences.
— Rédiger un code de façon claire avec des fonctions
— Respecter le nom de variables imposées
— Réaliser des graphiques scientifiques complets
— Réaliser une simulation d’interférences
— Comparer un résultat à un modèle théorique
— Présenter un résultat numérique
Ce TP se propose de simuler le résultat de l’expérience de Tonomura et al. (1992) (voir Fig. 1) vu
en cours. On se limitera à une simulation à une dimension (moins gourmande en calcul).
Figure 1 – Expérience d’interférences d’électrons. La figure d’interférences se construit au fur et à mesure que le
nombre de particules augmente. Source : Tonomura et al, Electron-holographic interference microscopy (1992).
Page 1/8
1 Principe
La simulation est dite à évènements :
— Création d’une particule et son trajet optique
— Détection de cette particule par un des capteurs sur le détecteur
Aucune information sur les particules ne sont précisées, elles peuvent être un photon ou un électron
(expérience de Tonomura). Le résultat numérique que l’on doit obtenir est présenté en Fig. 2. La
généralisation de cet algorithme à 3 dimensions donne le résultat en Fig. 3.
17.5 (a) 400
(b)
15.0
12.5 300
occurence
occurence
10.0
200
7.5
5.0
100
2.5
0.0 0
90 75 60 45 30 15 0 15 30 45 60 75 90 90 75 60 45 30 15 0 15 30 45 60 75 90
Figure 2 – Résultats de simulations 2D. (a) 104 particules. (b) 105 particules.
90 90
60
(a) 60
(b)
30 30
0 0
30 30
60 60
90 90
90 60 30 0 30 60 90 90 60 30 0 30 60 90
90 90
60
(c) 60
(d)
30 30
0 0
30 30
60 60
90 90
90 60 30 0 30 60 90 90 60 30 0 30 60 90
Figure 3 – Résultats de simulations 3D avec le même algorithme. (a) : 103 particules. (b) : 105 particules. (c) : 106
particules. (d) : 107 particules.
Page 2/8
Les particules sont émises une par une par une source en amont et elles se propagent selon la
direction x. Considérons une particule (voir la Figure 4) :
— La particule passe aléatoirement (avec une probabilité de 1/2) par une des fentes de largeur
a = λ et espacées de b = 4λ avec une ordonnée y aléatoire. La distribution de probabilité
sur l’ordonnée est uniforme.
— La particule est ensuite diffractée d’un angle beta aléatoire compris entre −π/2 et π/2. La
distribution de probabilité sur l’angle est uniforme.
— La particule arrive ensuite au point M sur le détecteur circulaire de rayon R avec un champ
électrique Ex et Ey.
— Le détecteur est circulaire et composé de n = 181 capteurs individuels qui sont repérés par
un indice k avec k = 0, ..., 179, 180.
— Un capteur possède une polarisation p~k notée px_k et py_k ; et un état de comptage occ_k.
— La détection de la particule dépend du champ électrique de la particule et de la polarisation
du capteur. La condition est précisée plus bas.
k=0 capteur
1
y 2
3
S
détecteur
β
b
R x
a M
178
179
180
Figure 4 – Schéma de l’expérience. Une particule passe par la fente du haut au point S et arrive sur le détecteur
au point M .
Page 3/8
2 Algorithme
Une bonne façon d’aborder un code ambitieux est de vérifier le résultat d’une étape avant de passer
à l’étape suivante. On commence par importer les librairies nécessaires :
import numpy as np
import [Link] as plt
2.1 Tirage de l’ordonnée
La probabilité de passer par une fente est 1/2. Le choix se fait par un tirage d’un nombre entier
que l’on affecte à une fente. Ensuite on tire un deuxième nombre pour l’ordonnée y de la particule
dans la fente. La largeur des fentes est a = 1 et elles sont distantes de b = 4.
a = 1 # largeur des fentes
b = 4 # distance entre les fentes
R = 100 # rayon de courbure du capteur
y = [] # ordonnee de la particule a la fente
N = 1000 # nombre de particules
for i in range(N):
choix_fente = [Link](...,...)
if choix_fente == ...:
[Link]([Link](-b/2 -a/2, -b/2 +a/2))
else:
[Link](...)
[Link](...,...)
[Link]()
1. Remplacer les pointillés par les arguments appropriés à l’aide de l’annexe.
2. Représenter la distribution des valeurs de y dans un histogramme de 50 points.
3. La distribution des valeurs de y est-elle vraiment uniforme ?
À présent il n’est plus nécessaire de conserver dans une liste les informations sur y. On peut
simplifier le code en remplaçant les instructions :
[Link]([Link](...,...))
par :
y = [Link](...,...)
et ces instructions peuvent être supprimées :
[Link](beta,50)
[Link]()
4. Effectuer ce changement pour la variable y.
Page 4/8
2.2 Tirage de l’angle de diffraction
Le tirage de l’angle beta est aléatoire et distribué uniformément entre -[Link]/2 et [Link]/2.
5. Implémenter le choix d’un angle de diffraction beta pour les N particules.
2.3 Chemin optique
6. Exprimer le chemin optique L = (SM ) en fonction de R, y et [Link](beta).
7. Implémenter dans une fonction longueur(y,beta) prenant en entrée y et beta de la particule
et en sortie L. Commenter les valeurs obtenues.
2.4 Champ électrique
L’amplitude du champ électrique de la particule source en S(0, y) est 1 et il faut calculer sa valeur
en M (R cos β, R sin β). On pose λ = 1. L’amplitude du champ électrique en M est (résultat admis) :
2π
Ex (M ) = cos (SM ) = cos(2πL),
λ
(2.1)
2π
Ey (M ) = sin (SM ) = sin(2πL).
λ
8. Implémenter dans une fonction champ(L) prenant en entrée le chemin optique L de la particule
et en sortie Ex et Ey.
2.5 Indice du capteur
Le détecteur est circulaire de rayon R et est composé de n = 181 capteurs individuels. Chaque
capteur k est repéré par un angle αk compris entre −π/2 et π/2. La particule sort de la fente avec
un angle beta et on souhaite savoir sur quel capteur elle est enregistrée, c’est-à-dire le numéro k.
9. Implémenter dans une fonction capteur(beta) prenant en entrée beta et en sortie le numéro
k du capteur (un entier) sur lequel la particule est enregistrée. Pour simplifier on considère que la
particule est située initialement à l’origine. On utilisera les instructions suivantes :
n = 181 # nombre de capteurs
alpha = [Link](-[Link]/2,[Link]/2,n) # distribution angulaire du detecteur
2.6 Détection (admis)
Le champ électrique d’une particule arrivant sur une cellule k entraîne un changement de polari-
sation du capteur. La polarisation du capteur k est traitée en perturbation 1 :
~
p~k ← g~pk + (1 − g)E, (2.2)
avec g = 0.99 le terme de "mémoire" du capteur. En python cela s’écrit :
px_k = g*px_k+(1-g)*Ex
py_k = g*py_k+(1-g)*Ey
1. Les curieux sont encouragés à se renseigner davantage.
Page 5/8
La détection d’une particule unique n’est pas assurée et peut être confondue avec le bruit. Le
bruit est modélisé par un nombre aléatoire 2 compris entre 0 et 1 :
— Si la norme P de la polarisation est plus grande que le bruit : on ajoute +1 au comptage.
— Sinon le comptage ne change pas.
Le code suivant réalise cet algorithme :
def detection(px_k,py_k,Ex,Ey):
g = 0.99 # "memoire" du capteur
px_k = g*px_k+(1-g)*Ex
py_k = g*py_k+(1-g)*Ey
P = (px_k**2+py_k**2)**0.5
bruit= [Link]()
test = P-bruit
if test >= 0:
m = 1
else:
m = 0
return px_k,py_k,m
[Link] une polarisation px_k et py_k pour chaque capteur ainsi que son état de comptage
occ_k à l’aide de l’annexe.
11. Ajouter la fonction detection(px_k,py_k,Ex,Ey) au script.
12. D’après l’annexe, qu’effectue l’instruction [Link]() ?
13. Que représente la variable m ?
À présent le programme doit être proche du code suivant :
for i in range(N):
choix_fente = [Link](...,...)
if choix_fente == ...:
y = [Link](-b/2 -a/2, -b/2 +a/2)
else:
y = ...
beta = [Link](...,...)
L = longueur(y,beta)
Ex,Ey = champ(L)
k = capteur(beta)
# entree: pol. initiale + Ex,Ey / sortie: pol. finale + detection
px_k[k],py_k[k],m = detection(px_k[k],py_k[k],Ex,Ey)
occ_k[k] = occ_k[k] + m # comptage de particules
2. La nature du bruit n’est pas importante. Ici on se propose un bruit distribué uniformément mais on pourrait prendre une
distribution normale.
Page 6/8
3 Étude quantitative
[Link]ésenter graphiquement le nombre de détection en fonction de l’abscisse angulaire. Réaliser
une simulation pour N = 103 , 104 , et 105 . Enregistrer les figures dans une page à rendre au
format pdf. Ne pas rendre le code.
15. Commenter l’évolution des résultats obtenus en fonction de N.
16. Mesurer l’interfrange angulaire des simulations.
17. Comparer l’interfrange angulaire à sa valeur attendue.
18. En se basant sur le cours, relier les grandeurs de la simulation aux indéterminations spatiales.
19. À quel aspect ondulatoire ou corpusculaire ce résultat est-il associé ? Conclure.
Page 7/8
Annexe
Librairies utilisées pour cette simulation :
import numpy as np
import [Link] as plt
Méthodes utiles pour cette simulation :
[Link](a,b,n) # n valeurs regulierement espacees entre a et b
[Link](n) # "liste" de n zeros (numpy array)
Nombres aléatoires :
[Link](0,2) # genere aleatoirement un entier entre 0 inclut et 2
,→ exclu
[Link](a,b) # genere aleatoirement un nombre entre a inclut et b
,→ inclut
[Link]() # genere aleatoirement un nombre entre 0 inclut et 1
,→ exclu
Méthodes mathématiques :
[Link]
[Link](x)
[Link](x)
Méthodes graphiques :
[Link](x,y)
[Link](x,bins=10) # trace un histogramme de x sur 10 echantillons
[Link]("x")
[Link]("y")
[Link]()
Méthodes gestion de fichier :
[Link]("[Link]",[Link]([x,y]))
x,y = [Link]("[Link]",unpack=True)
Page 8/8
import numpy as np
import [Link] as plt
def longueur(y,beta):
l = (R**2 + y**2 - 2*R*y*[Link](beta))**0.5
return l
def champ(l):
Ex = [Link](2*[Link]*l)
Ey = [Link](2*[Link]*l)
return Ex,Ey
def cellule(beta):
for i in range(n-1):
if alpha[i] <= beta <= alpha[i+1]:
k = i
return k
def detection(px_k,py_k,Ex,Ey):
g = 0.99 # "memoire" du capteur
px_k = g*px_k+(1-g)*Ex
py_k = g*py_k+(1-g)*Ey
P = (px_k**2+py_k**2)**0.5
bruit= [Link]()
test = P-bruit
if test >= 0:
m = 1
else:
m = 0
return px_k,py_k,m
N = 50000
# parametres fentes
a = 1
b = 4
# parametres detecteur
R = 100
n = 181 # chaque capteur est espace de 1 degre
px_k = [Link](n) # chaque capteur possede une polarisation
py_k = [Link](n)
occ_k = [Link](n)
alpha = [Link](-[Link]/2,[Link]/2,n)
for i in range(N): # a chaque iteration, creation d'une particule
choix_fente = [Link](0,2) # 2 est exclu donc 0 ou 1
if choix_fente == 0:
y = [Link](-a/2-b/2 , a/2-b/2)
else:
y = [Link](-a/2+b/2 , a/2+b/2)
beta = [Link](-[Link]/2,[Link]/2)
L = longueur(y,beta)
Ex,Ey = champ(L)
k = cellule(beta)
px_k[k],py_k[k],m = detection(px_k[k],py_k[k],Ex,Ey)
occ_k[k] += m
[Link](alpha*180/[Link],occ_k)
[Link]([-90,-75,-50,-25,0,25,50,75,90])
[Link](r'$\alpha$') # r et $ pour utiliser du latex
[Link]('occurence')
[Link]()