Électromagnétisme

Rayonnement





Code Python pour cette dernière vidéo :
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import fsolve
import os

x0 = 0.2

def beta_function(t):
    return np.array([0.,-x0*c*np.sin(np.pi*t),0]) 
def beta_dot_function(t):
    return np.array([0,-x0*c*np.pi*np.cos(np.pi*t),0])

c = 1

def r_0(t):
    return np.array([float(0.),float(x0*c/np.pi*np.cos(np.pi*t)),0]) 

def determinetprime(r,r_0,t):
    """
    r_0(t_prime) est la fonction donnant la position au cours du temps
    r est le point où on cherche la valeur du champ
    """
    def func(t_prime):
        return t - t_prime - np.linalg.norm(r - r_0(t_prime)) / c
    t_prime_initial_guess = t - 1
    t_prime_solution = fsolve(func, t_prime_initial_guess)
    return t_prime_solution[0]

def champ_vectorized(x_grid, y_grid, r_0_func, beta_function, beta_dot_function, t):
    q = 1
    E_field = np.zeros(x_grid.shape + (3,))  # Initialisation d'un tableau 3D pour le champ électrique
    for i in range(x_grid.shape[0]):
        for j in range(x_grid.shape[1]):
            r = np.array([x_grid[i, j], y_grid[i, j], 0])
            tprime = determinetprime(r, r_0_func, t)
            beta = beta_function(tprime)
            beta_dot = beta_dot_function(tprime)
            r0 = r_0_func(tprime)
            R = r - r0
            R_norm = np.linalg.norm(R)
            R_hat = R / R_norm
            gamma = 1 / np.sqrt(1 - np.dot(beta, beta))
            term1_numerator = R_hat - beta
            term1_denominator = gamma**2 * R_norm**2 * (1 - np.dot(R_hat, beta))**3
            term1 = term1_numerator / term1_denominator
            term2_numerator = np.cross(R_hat, np.cross(R_hat - beta, beta_dot))
            term2_denominator = c * R_norm * (1 - np.dot(R_hat, beta))**3
            term2 = term2_numerator / term2_denominator
            E = q * (term1 + term2)
            E_field[i, j, :] = E
    return E_field

def calculate_field_line_point(r0, beta, n_hat, t, t_prime):
    gamma = 1 / np.sqrt(1 - np.dot(beta, beta))  # Facteur de Lorentz
    if np.linalg.norm(beta) != 0:
        beta_hat = beta/np.linalg.norm(beta)
    else:
        beta_hat = np.array([0.0,0.0,0.0])
    term_inside_brackets = beta + ((1/gamma - 1) * np.dot(n_hat, beta_hat) * beta_hat + n_hat) / (gamma * (1 + np.dot(n_hat, beta)))
    return r0 + c * (t - t_prime) * term_inside_brackets

# Fonction pour tracer les lignes de champ à partir d'une position donnée à l'instant t
def plot_field_lines(r0_func, beta_func, t, num_lines=24, num_points=500, step=0.05):
    for i in range(num_lines):
        n_hat = np.array([np.cos(i/num_lines*2*np.pi),np.sin(i/num_lines*2*np.pi),0])
        line_points = []
        t_prime = t  # Initialisation de t' à la valeur de t pour le début de la ligne de champ
        for _ in range(num_points):
            r0 = r0_func(t_prime)
            beta = beta_func(t_prime)
            point = calculate_field_line_point(r0, beta, n_hat, t, t_prime)
            line_points.append(point)
            t_prime -= step  # Décrémentation de t' pour suivre la ligne de champ vers le passé

        line_points = np.array(line_points)
        plt.plot(line_points[:, 0], line_points[:, 1], 'r-')  # Trace la ligne en rouge

# Set up grid for field calculation
x_range = np.linspace(-12, 12, 1200)
y_range = np.linspace(-6, 6, 600)
x_grid, y_grid = np.meshgrid(x_range, y_range)

# Créer le répertoire pour les images si nécessaire
output_dir = "animation"
if not os.path.exists(output_dir):
    os.makedirs(output_dir)

# Définir la plage de temps et le nombre d'images
time_values = np.linspace(0, 2, num=51)  # 401 images pour t de 0 à 4
for i, t in enumerate(time_values):
    plt.figure(figsize=(15, 10), dpi=150)
    plot_field_lines(r_0, beta_function, t)
    
    E_field_grid = champ_vectorized(x_grid, y_grid, r_0, beta_function, beta_dot_function, t)
    E_field_magnitude = np.linalg.norm(E_field_grid, axis=2)
    
    plt.imshow(np.log10(E_field_magnitude), extent=(x_range.min(), x_range.max(), y_range.min(), y_range.max()), cmap='Spectral_r', aspect='equal')
    plt.axis('off')
    
    # Construire le nom de fichier avec un remplissage de zéros
    filename = f"image{str(i).zfill(4)}.png"
    filepath = os.path.join(output_dir, filename)
    
    # Sauvegarder l'image
    plt.savefig(filepath, bbox_inches='tight', pad_inches=0, transparent=True)
    
    # Fermer la figure pour libérer de la mémoire
    plt.close()
Ce code a été obtenu à partir de cet article et de cette page de forum.

Arc électrique

Le champ disruptif d’un isolant, ou plutôt sa rigidité diélectrique, désigne la valeur maximum du champ électrique que le milieu peut supporter avant le déclenchement d’un arc électrique, ou claquage.

Pour l’air, la valeur fréquemment admise est de 36 kV/cm dans l’air sec et tombe à 10 kV/cm pour un air saturé en humidité. Cela signifie qu’il faut, dans l’air sec, une tension d’au moins 36 kV entre deux électrodes séparées d’un centimètre pour qu’une étincelle se crée entre elles.

Comment obtenir cet ordre de grandeur ?

Un arc électrique est un conduit d’air ionisé. Comment ce chemin de molécules ionisées apparait-il ? Imaginons qu’un électron est arraché à une molécule d’air. Il est alors accéléré par le champ électrique ambiant. Si au moment de rencontrer une nouvelle molécule, l’électron a atteint une énergie suffisante pour la ioniser, on va se retrouver avec une cascade d’ionisations successives.

Le secret est donc d’avoir un champ suffisant pour donner à un électron une énergie d’environ 10 eV sur une distance correspondant au libre parcours moyen de cet électron dans l’air.

Faisons le point sur le libre parcours moyen dans un gaz de particules identiques de rayon $d$ et de densité $n$ :

La section efficace de collision $\sigma$ vaut $\pi d^2$.

La valeur de la vitesse relative entre deux particules vaut :

$$ \begin{aligned} v_{rel}&=\sqrt{\vec{v}_{rel}\cdot \vec{v}_{rel}}\\ &=\sqrt{\left(\vec{v}_2-\vec{v}_1\right)\cdot\left(\vec{v}_2-\vec{v}_1\right)}\\ &=\sqrt{\vec{v}_2\cdot\vec{v}_2+\vec{v}_1\cdot\vec{v}_1-2\vec{v}_2\cdot\vec{v}_1} \end{aligned} $$

Et si on veut maintenant la vitesse relative moyenne. On va supposer que les vitesses se répartissent aléatoirement selon une certaine distribution de probabilité.

$$ \begin{aligned} \overline{v_{rel}}&=\sqrt{\overline{\vec{v}_2\cdot\vec{v}_2}+\overline{\vec{v}_1\cdot\vec{v}_1}-2\,{\cancel{\overline{\vec{v}_2\cdot\vec{v}_1}}}}\\ &= \sqrt{\overline{\vec{v}_2^2}+\overline{\vec{v}_1^2}}\\ &= \sqrt{2}\overline{v} \end{aligned} $$

On suppose en effet que les vitesses des particules 1 et 2 ne sont pas corrélées et que leur valeur moyenne est la même.

Le nombre de collisions d’une particule pendant un laps de temps $\Delta t$ peut être estimé comme le nombre moyen de fois que le centre de masse d’une particule se trouve dans le volume balayé par la section efficace pendant $\Delta t$, c’est-à-dire sur une distance $\overline{v_{rel}}\Delta t$.

Le volume en question vaut $V=\sigma \overline{v_{rel}}\Delta t = \pi d^2 \sqrt{2} \overline{v}\Delta t$. Et le nombre de particules rencontrées vaut donc $nV=n\sqrt{2}\pi d^2 \overline{v}\Delta t$.

Le libre parcours moyen $\lambda$ va alors correspondre à la distance parcourue pendant $\Delta t$ divisée par le nombre de collisions ayant eu lieu pendant ce laps de temps. D’où :

$$ \begin{aligned} \lambda &= \frac{\cancel{\overline{v}\Delta t}}{\sqrt{2}n\pi d^2 {\cancel{\overline{v}\Delta t}}}\\ &=\frac{1}{\sqrt{2}n\pi d^2} \end{aligned} $$

Le libre parcours moyen ne dépend donc que de la taille des particules et de leur densité, pas de leur vitesse relative.

Pour un gaz à une pression $P$ et une température $T$, on peut utiliser en première approximation la relation des gaz parfait pour remplace la densité $n$ par $P/k_B T$ :

$$ \lambda = \frac{k_B T}{\sqrt{2}P\pi d^2} $$

Une molécule de diazote a un diamètre $d=\pu{0,37 nm}$ et pour une pression $P=\pu{1 bar}$ et une température $T = \pu{293 K}$, on obtient un libre parcours moyen $\lambda\approx \pu{66 nm}$. On peut remarquer que c’est plus de 200 fois plus grand que la distance moyenne entre particules donnée par $n^{\frac{1}{3}}=\left(\frac{P}{k_B T}\right)^{\frac{1}{3}}\approx \pu{3,4 nm}$.

Pour un électron, on peut reprendre la formule du libre parcours moyen en modifiant seulement un peu la section efficace puisque $\sigma=\pi\left(r_\text{molécule}+r_\text{électron}\right)^2\approx \left(r_\text{molécule}\right)^2 = \pi d^2 /4$.

Et donc $\lambda= \frac{2\sqrt{2}k_B T}{P\pi d^2}\approx 0,27 \text{ μm}$.

Notre électron devant récupérer une énergie d’environ $\pu{16 eV}$ sur la distance $\lambda$ pour réussir à ioniser la prochaine molécule de diazote rencontrée, le champ doit donc être de $\pu{16 V}/\lambda$, soit à peu près $\pu{16 V}$ pour $0,27 \text{ μm}$, soit environ $0,59\text{ MV/cm.}$ C’est plus d’un ordre de grandeur au-dessus de ce qu’on aurait aimé obtenir 😢

Mais sur un tel processus statistique, on peut raisonnablement penser que seule une fraction de collisions “efficaces” est nécessaire pour déclencher la cascade de ionisations, surtout pour une distance très supérieure au libre parcours moyen. Il n’est donc pas choquant qu’un champ plus faible fasse l’affaire.