Table des matières Python

Particule chargée dans le champ d'un fil rectiligne chargé

1. Introduction

Ce document traite le mouvement d'une particule chargée dans le champ électrostatique créé par un fil rectiligne infini.

2. Équations du mouvement

Un fil rectiligne infini porte une charge uniforme de densité linéique λ>0. Oz étant un axe confondu avec le fil, on utilise les coordonnées cylindriques (r,θ,z). Le potentiel électrostatique créé par ce fil est :

Le champ électrique est :

On considère une particule chargée de masse m et de charge négative -q en mouvement dans ce champ. Comme la composante selon z de la force est nulle, on se limite à un mouvement dans un plan perpendiculaire au fil, où la particule est repérée par ses coordonnées polaires (r(t),θ(t)).

Il s'agit d'un problème de force centrale avec un champ en 1/r. La conservation du moment cinétique s'écrit :

La conservation de l'énergie mécanique s'écrit :

Ce problème à deux degrés de liberté possède deux intégrales premières (L et E); c'est donc un problème intégrable.

Les deux derniers termes constituent le potentiel radial effectif :

Ce potentiel admet un minimum et tend vers l'infini lorsque r tend vers zéro et l'infini. On en déduit que le mouvement de la particule est toujours borné.

La seconde loi de Newton en projection sur la direction radiale est :

En utilisant la conservation du moment cinétique, on en déduit le système d'équations du premier ordre suivant :

À l'instant initial, la particule se trouve à une distance r0 avec une vitesse v0 dont la direction est à une distance b du fil chargé (b est le paramètre d'impact). Le moment cinétique est ainsi L=mbv0 et les conditions initiales sont :

Pour le calcul numérique, il est préférable d'utiliser des grandeurs sans dimensions. On effectue pour cela les substitutions suivantes :

Les équations s'écrivent alors :

L'énergie mécanique s'écrit :

Finalement, les deux paramètres sans dimensions sont :

3. Intégration numérique

On utilise la fonction scipy.integrate.odeint. Cette fonction utilise le solveur LSODA de la bibliothèque fortran ODEPACK. La méthode utilisée par ce solveur est une méthode à pas multiple et à ordre variable.

import math
import numpy
from matplotlib.pyplot import *
import scipy.integrate
            

On définit les paramètres puis le système d'équations, avec z[0]=r,z[1]=vr,z[2]=θ :

alpha=1.0
beta=0.1
def equation(z,t):
    return [z[1],beta**2*math.pow(z[0],-3)-alpha/z[0],beta/(z[0]*z[0])]
            

On choisit le temps maximal du calcul et la période d'échantillonnage puis on crée le tableau des instants :

tmax=50
te=0.01
t = numpy.arange(start=0,stop=tmax,step=te)
            

La condition initiale :

theta0 = math.asin(beta)
z0 = [1.0,-1.0,theta0]
            

L'intégration numérique :

z = scipy.integrate.odeint(equation,z0,t,rtol=1e-7,atol=1e-7)
zt = z.transpose()
r = zt[0]
vr = zt[1]
theta = zt[2]
energie = 0.5*numpy.power(vr,2)+0.5*beta**2*numpy.power(r,-2)+alpha*numpy.log(r)
            

Tracé du rayon et de l'angle en fonction du temps :

figure(figsize=(8,5))
plot(t,r)
xlabel('t')
ylabel('r')
            
figAfigA.pdf
figure(figsize=(8,5))
plot(t,theta)
xlabel('t')
ylabel('theta')
            
figBfigB.pdf

Tracé de la trajectoire :

figure(figsize=(8,8))
polar(theta,r)
xlabel('x')
ylabel('y')
            
figCfigC.pdf

On trace aussi l'énergie pour vérifier sa conservation :

figure(figsize=(8,5))
plot(t,energie)
xlabel('x')
ylabel('y')
            
figDfigD.pdf

La variation relative d'énergie est très faible. On constate toutefois un petit décalage d'énergie qui survient à chaque fois que la particule passe au plus proche du fil.

Voyons la trajectoire pour un paramètre d'impact plus grand :

beta=0.5
theta0 = math.asin(beta)
z0 = [1.0,-1.0,theta0]
z = scipy.integrate.odeint(equation,z0,t,rtol=1e-7,atol=1e-7)
zt = z.transpose()
r = zt[0]
vr = zt[1]
theta = zt[2]
energie = 0.5*numpy.power(vr,2)+0.5*beta**2*numpy.power(r,-2)+alpha*numpy.log(r)
figure(figsize=(8,8))
polar(theta,r)
xlabel('x')
ylabel('y')
            
figEfigE.pdf

4. Angle de déviation

On s'intéresse à présent à la déviation de la particule lors de son premier passage à proximité du fil.

alpha=1.0
tmax=2.0
te=0.01
t = numpy.arange(start=0,stop=tmax,step=te)
n=10
bmax=0.5
figure(figsize=(8,8))
xlabel('x')
ylabel('y')
for i in range(n):
    beta = (i+1)*bmax/n
    z = scipy.integrate.odeint(equation,[1.0,-1.0,math.asin(beta)],t,rtol=1e-7,atol=1e-7)
    zt = z.transpose()
    r = zt[0]
    theta = zt[2]
    polar(theta,r)
                
figFfigF.pdf

L'angle de déviation augmente avec le paramètre d'impact. Si le faisceau de départ est assez étroit, il a probablement convergence vers un foyer. Voyons ce qui se passe si on augmente l'énergie cinétique initiale de la particule, ce qui revient à diminuer le paramètre α :

alpha=0.1
tmax=2.0
te=0.01
t = numpy.arange(start=0,stop=tmax,step=te)
n=10
bmax=0.5
figure(figsize=(8,8))
xlabel('x')
ylabel('y')
for i in range(n):
    beta = (i+1)*bmax/n
    z = scipy.integrate.odeint(equation,[1.0,-1.0,math.asin(beta)],t,rtol=1e-7,atol=1e-7)
    zt = z.transpose()
    r = zt[0]
    theta = zt[2]
    polar(theta,r)
                
figGfigG.pdf

Cette fois les angles de déviation sont très proches (il y a convergence beaucoup plus loin). Le fil agit ici comme un prisme en optique, en déviant un faisceau de rayons parallèles.

Creative Commons LicenseTextes et figures sont mis à disposition sous contrat Creative Commons.