Paquet d'onde

1. Introduction

Ce document montre comment calculer des paquets d'onde par combinaison linéaire d'ondes de de Broglie. On utilise un système d'unités où $ℏ = 1$ et m=1.

2. Définition des paquets d'onde

Une onde de de Broglie pour une particule d'impulsion p et d'énergie E=p²/2 s'écrit :

ψ (x, t) = A e^{i (p x - E t)} (1)

On considère la superposition suivante :

ψ (x, t) = \sum_{j} A (p_{j}) e^{i (p_{j} x - E_{j} t)} (2)

Le spectre en impulsion de cette onde comporte des raies d'impulsion p_j et d'énergie E_j=p_j²/2.

Pour définir un paquet d'onde gaussien, on doit définir un spectre gaussien centré sur une impulsion p₀. Pour la raie d'impulsion p=p₀+n, l'amplitude est :

A (p) = e^{- \frac{{(p - p_{0})}^{2}}{4 {(Δ p)}^{2}}} (3)

La densité de probabilité en impulsion est alors :

| A (p) |^{2} = e^{- \frac{{(p - p_{0})}^{2}}{2 {(Δ p)}^{2}}} (4)

Δp est l'écart-type en impulsion. Il est lié à l'écart-type en position Δx par l'inégalité d'Heisenberg :

Δ x Δ p \geq \frac{1}{2} (5)

Pour le paquet d'onde gaussien, l'égalité est réalisée à t=0. Pour t>0, la largeur Δx du paquet augmente.

Le nombre de raies de part et d'autre de la raie centrale doit être choisi pour que la dernière raie soit au bord de la gaussienne. Le choix suivant convient :

n_{r a i e s} = 4 Δ p (6)

L'onde résultante comporte une succession périodique de paquets d'ondes. Pour suivre un paquet d'onde en particulier, celui qui se trouve au voisinage de x=0 à l'instant t=0, on doit utiliser la vitesse de groupe :

V_{g} = \frac{d E}{d p} = p_{0} (7)

La fonction d'onde calculée n'est pas normalisée.

3. Fonctions Python

PaquetOndeParticule.py

import numpy


class PaquetOndeParticule: 
    def __init__(self,suivi):
        self.suivi = suivi
        self.p = []
        self.E = []
        self.A = []
        
    def spectre_gaussien(self,p0,delta_p):
        self.p = []
        self.E = []
        self.A = []
        delta_p=delta_p*1.0
        n_raies = int(4*delta_p)
        def amplitude(n):
            return numpy.exp(-n*n/(4*delta_p**2))
        for n in range(-n_raies,n_raies+1):
            p = p0+n
            self.p.append(p)
            self.E.append(p*p/2)
            self.A.append(amplitude(n))
        self.N_raies = n_raies*2+1
        self.v_groupe = p0
        return (numpy.array(self.p),numpy.array(self.A))
        
    def echantillons(self,xmin,xmax,t,N):
        x = numpy.linspace(xmin,xmax,N)
        psi = numpy.zeros(x.size,dtype=numpy.complex)
        for i in range(self.N_raies):
            p = self.p[i]
            E = self.E[i]
            phase = p*x+(p*self.v_groupe*self.suivi-E)*t
            psi += self.A[i]*numpy.exp(1j*phase)
        proba = numpy.real(numpy.conj(psi)*psi)
        return (x,numpy.real(psi),proba)

4. Exemple

import numpy
from matplotlib.pyplot import *
from PaquetOndeParticule import *

paquet = PaquetOndeParticule(True)
p0=100
delta_p = 5
(p,A)=paquet.spectre_gaussien(p0,delta_p)
figure()
stem(p,A*A)
xlabel("p")
ylabel("A^2")
axis([0,200,0,1])
grid()

Figure pleine page

figure()
xmin=-2
xmax=2
N=5000
(x,re_psi,proba) = paquet.echantillons(xmin,xmax,0.0,N)
plot(x,re_psi)
xlabel("x")
ylabel("Re(psi)")
grid()

Figure pleine page

figure()
plot(x,proba)
xlabel("x")
ylabel("|psi|^2")
grid()

Figure pleine page

5. Animation

import matplotlib.animation as animation

fig, ax = subplots()
line, = ax.plot(x,proba)
ax.grid()
temps = 0.0
dt = 1.0e-4

def animate(i):
    global temps,xmin,xmax,N
    temps += dt
    (x,re_psi,proba) = paquet.echantillons(xmin,xmax,temps,N)
    line.set_xdata(x)
    line.set_ydata(proba)
    return line,

ani = animation.FuncAnimation(fig,animate,1000,interval=40)
    
show()

Paquet d'onde d'une particule matérielle

1. Introduction

2. Définition des paquets d'onde

3. Fonctions Python

4. Exemple

5. Animation