But

• Simuler un phénomène physique vu en cours à l’aide du langage C
• Visualiser les lignes de champs électriques générées par N particules

Rappel théorique

Comme nous l’avons vu en classe, chaque particule possédant une charge \(Q\) induit un champs \(E\) qui influe sur l’espace autour d’elle. Il est possible de représenter ce champs électrique à l’aide d’un champs de vecteur. Lorsque que l’on a une seule particule chargée, chaque vecteur décrit en un point l’action induite par la particule chargée à cette distance. L’intensité de ce champs à une distance \(r\) de la particule est donné par la formule suivante :

\[ E = k\frac{Q}{r^2} \qquad \mbox{avec}\ k=\frac{1}{4\pi\epsilon_0} \qquad{(2.1)}\]

En ce qui concerne sa direction, si \(Q>0\) alors le vecteur va chercher à s’éloigner de la particule, et si \(Q<0\) alors le vecteur est dirigé vers la particule.

En réalité, on rencontre souvent (très souvent) plus d’une particule chargée, dans ce cas, on se sert du principe de superposition des champs électriques. Le vecteur en un point représente alors la résultante des actions induites par chacune de nos particules chargées.

Une autre représentation du champs électrique peut se faire à l’aide de courbes appelées lignes de champs.

Pour réaliser cette simulation numérique, nous devons commencer par définir notre univers discret. Dans le cadre de ce travail, notre univers est un rectangle \([0;1]\times[0;1]\).

Chaque particule possède une position appartenant à notre univers, ainsi qu’une charge (multiple de la charge élémentaire).

Pour dessiner numériquement une courbe, une méthode consiste à l’approximer à l’aide d’un ensemble de segments de droites reliant des points appartenant à cette courbe. Pour dessiner notre ligne de champs, nous devons donc trouver un ensemble de points appartenant à cette ligne. Pour cela on travaille ainsi :

1. On tire aléatoirement un point dans notre univers \(P_0\).
2. On assigne \(P=P_0\)
3. On calcule \(P_{suivant}\) à partir de l’intensité et la direction du champs en \(P\), ce qui nous donne \(P_{suivant}=P+\sum_{i}^{N}E_i\cdot\frac{\vec{q_iP}}{||\vec{q_iP}||}\) avec \(\vec{q_iP}\) le vecteur allant de la particule chargée \(q_i\) au point \(P\). Dans notre cas, on souhaite avancer d’une même distance à chaque fois, et qui ne soit pas trop grande. On va donc commencer par normaliser le champs, puis on va ajouter une constante \(\delta x\) qui est fixe pour notre programme et qui est définie en fonction de la taille de notre fenêtre. Ce qui nous donne \(P_{suivant}=P+\delta x\cdot\frac{\vec{E}}{||\vec{E}||}\) avec \(\delta x = \frac{1}{\sqrt{\mbox{largeur}^2+\mbox{hauteur}^2}}\) et \(\vec{E} = \sum_{i}^{N}E_i\cdot\frac{\vec{q_iP}}{||\vec{q_iP}||}\).
4. Si \(P\) et \(P_{suivant}\) sont à une distance des particules, supérieure à un seuil choisi et qu’ils sont toujours dans notre univers, on trace un segment entre \(P\) et \(P_{suivant}\). Sinon, on quitte notre boucle.
5. On assigne \(P=P_{suivant}\) et on revient à l’étape 3

Cette méthode nous permet de dessiner partiellement notre ligne de champs. Comme nous partons d’un point aléatoire, il faut également dessiner le reste de la ligne en allant dans le sens opposé. Il faudra donc réitérer notre processus, en partant à nouveau de la deuxième étape, mais en calculant \(P_{suivant}=P-\delta x\cdot\frac{\vec{E}}{||\vec{E}||}\).

Énoncé

Vous allez développer une simulation de lignes de champs générée par un ensemble de particules en C, et visualiser le résultat à l’aide de la librairie SDL. Vous devez réutiliser la librairie de vecteurs en deux dimensions réalisée au premier semestre. Deux fichiers utils.h et utils.c vous seront fournis avec l’énoncé. Le fichier utils.c contient des méthodes afin de vous faciliter la réalisation de ce TP. Pour récupérer ces fichiers vous pouvez exécuter la commande

wget https://malaspinas.academy/phys/field_lines/utils.tar.gz

Ce travail va se diviser en deux parties.

Dessin

Pour pouvoir représenter ce que vous allez calculer dans la deuxième partie, vous allez devoir dessiner des droites et des cercles à l’aide des méthodes présentées en cours. Pour cela vous implémenterez les fonctions suivantes :

typedef struct
{
    uint32_t row;
    uint32_t column;
} coordinates_t;

void gfx_draw_line(struct gfx_context_t *ctxt, coordinates_t p0, 
  coordinates_t p1, uint32_t color);

void gfx_draw_circle(struct gfx_context_t *ctxt, coordinates_t c, 
  uint32_t r, uint32_t color);

Pour tester votre fonction de dessin de droites, vous dessinerez dans une fenêtre de \(100\times 100\) les droites suivantes :

• \((50,50) \rightarrow (75,50)\)¹, \((50,50) \rightarrow (72,62)\), \((50,50) \rightarrow (62,72)\);
• \((50,50) \rightarrow (50,75)\), \((50,50) \rightarrow (38,72)\), \((50,50) \rightarrow (28,62)\);
• \((50,50) \rightarrow (25,50)\), \((50,50) \rightarrow (28,38)\), \((50,50) \rightarrow (37,28)\);
• \((50,50) \rightarrow (50,25)\), \((50,50) \rightarrow (62,28)\), \((50,50) \rightarrow (72,37)\).

Physique

Comme nous l’avons vu durant la partie théorique, vous allez devoir calculer différents points appartenant à différentes lignes de champs. Pour cela vous implémenterez les fonctions suivantes :

typedef struct
{
  double q;
  vec2 pos;
} charge_t;

// Compute E*qP/norm(qP)
// Return false if norm(qP) < eps
bool compute_e(charge_t c, vec2 p, double eps, vec2 *e);

// Compute the normalized sum of Ei*qiP/norm(qiP)
// Return false if for some qiP, norm(qiP) < eps
bool compute_total_normalized_e(charge_t *charges, int num_charges, vec2 p, 
      double eps, vec2 *e);

// Compute and then draw all the points belonging to a field line, 
// starting from pos0.
// Returns false if pos0 is not a valid position 
// (for example if pos0 is too close to a charge).
static bool draw_field_line(struct gfx_context_t *ctxt, charge_t *charges,
                            int num_charges, double dx, vec2 pos0, double x0, 
                            double x1, double y0, double y1);

// Draw all the charges
// A circle with minus sign for negative charges
// A circle with a plus sign for positive charges
static void draw_charges(struct gfx_context_t *context, charge_t *charges,
            int num_charges, double x0, double x1, double y0, double y1);

Travail à rendre (par groupe de deux)

• Un rapport succinct (moins de 6 pages) présentant le travail réalisé, avec des images de ce dernier;
• Le repos git contenant le code réalisé.

Rappel sur le rapport

La structure du rapport doit être la suivante:

Introduction

La partie introductive place le cadre du travail: elle nous dit à quoi sert notre travail dans la vraie vie (c’est pas “le prof nous a demandé de…” ou “on a fait un TP de maths …”). De plus, elle explique ce que contient votre travail et annonce votre réalisation. Elle sert également à donner la structure de votre travail (que va contenir chaque chapitre/section).

Théorie

Un rappel théorique est nécessaire pour présenter les notions utilisées dans votre travail (formules mathématiques importantes, notions physiques, etc.). Il sert à clarifier les notations et expliquer comment vous avez réalisé votre travail.

Résultats

Présentation de votre réalisation en détail. Quelles expériences avez-vous réalisées? Par quels moyens? Donnez des détails. Typiquement, vous devez reprendre les objectifs que avez annoncés comme travail lors de l’introduction et devez discutez s’ils ont été atteints ou non et éventuellement les raisons de l’échec, du taux de réussite, etc. Il est primordial que chaque image, tableau, etc. soit discuté en détail. Que voit-on sur l’image/tableau? Qu’est-ce qui est important selon vous?

Conclusion

Résumé (rappel) de ce qui a été fait dans le travail et quels sont les résultats importants. Ouverture sur la suite: comment améliorer le travail? comment l’intégrer dans un cadre plus large?

Remarques

Vérifiez bien vos formules et l’orthographe. Il est totalement inutile de mettre des images ou tableaux sans qu’ils soient discutés. Le lecteur ne doit pas avoir à deviner pourquoi vous avez mis une figure ou un tableau. Évitez les phrases du type: “j’ai beaucoup aimé ce travail parce que j’ai beaucoup appris”, si vous voulez faire un retour “réflexif”, essayez de le formuler de façon factuelle.

Travail supplémentaire possible

Dynamique

Pour un bonus sur votre travail, vous pouvez coupler le résultat de ce travail avec le travail pratique sur les planètes. Dans ce qui précède les charges ne bougent pas, elles sont complètement statiques.

L’idée, pour ce travail supplémentaire, est de simuler l’évolution temporelle du système. Cette évolution est à faire de la même façon que pour l’évolution temporelle des planètes, mais en remplaçant la force de gravité par la force électrostatique. Ainsi, pour ce travail il s’agit de faire “un certain nombre de fois:

0. Initialiser les particules et leurs charges (comme dans la partie principale).
1. Afficher les lignes de champs électrique (comme dans la partie principale).
2. Calculer la force électrostatique sur chacune des particules.
3. Faire avancer les particules (comme lors du TP sur les planètes).
4. Recommencer en 1.

Cette partie n’a pas besoin d’être dans le rapport, c’est uniquement une partie implémentation. Une jolie vidéo avec une musique épique serait souhaitable.