Skip to content
Snippets Groups Projects
Commit 5b49e99f authored by Boris Stefanovic's avatar Boris Stefanovic
Browse files

EDIT: proposition rapport

parent 8a3e4543
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
doc/E_FieldOnePointCharge.png 0 → 100644
+ 0
− 0
View file @ 5b49e99f
doc/E_FieldOnePointCharge.png

37.1 KiB

doc/fieldlines.jpg 0 → 100644
+ 0
− 0
View file @ 5b49e99f
doc/fieldlines.jpg

54 KiB

doc/rapport.md
+ 214
− 98
View file @ 5b49e99f
---
title: Physique - Travail Pratique, Champs Electriques
author: Boris Stefanovic, Joey Martig
date: 2022-04-25
title: Champs Electriques - Travail Pratique
author:
- MARTIG Joey
- STEFANOVIC Boris
date: 2022-05-22
geometry: "margin=35mm"
mainfont: DejaVu Sans
fontsize: 12pt
fontsize: 10pt
header-includes:
- \usepackage{float}
- \let\origfigure\figure
......@@ -12,133 +14,247 @@ header-includes:
- \renewenvironment{figure}[1][2] {\expandafter\origfigure\expandafter[H]} {\endorigfigure}
---
# Intro
Ce projet consiste à simuler des charge électriques ainsi que des lignes de champs qui permettent de représenter le champ électrique généré par les charges. Pour ce faire, nous créons des charges et les positionnons dans un espace que nous avons créé. Nous ajoutons ensuite les lignes de champs dans cet espace, ce qui nous permet de visualiser les champs électriques. Le champs électrique est influencé par le nombre de charges présentent, l'intensité des charges ainsi que leur valeur (positive ou négative). Pour se raprocher au maximum de la réalité, il est important d'utiliser des formules mathématiques. Ces formules permettent de correctement simuler les lignes de champs entre les charges.
Une charge électrique est un atome électriquement chargé, ce qui signifie qu'il possède soit un suprlus d'électron, le rendant positif, ou un déficit d'électron le rendant négatif. Une charge non neutre va donc émettre un champ électrique autour d'elle. Si une multitude de charges sont présentes, celles-ci auront toutes un impact prochent d'elles. Leur intensité fait aussi grandemant varié leur effet sur le champ électrique.
# Introduction
Une ligne de champs nous permet de visualiser le champ électrique généré par les charges. Dans notre cas, nous prenons un endroit aléatoire dans notre espace (Hors charge) et calculons le champs électrique à ce point. Cela nous donne une direction, nous nous déplacons dans cette direction puis recommencons l'ôpération. Le résultat de ce processus nous donne une ligne partant d'une charge et se dirigeant vers une autre ou au contraire, s'éloignant de celle-ci.
Le champ électrique est un _champ vectoriel_ généré par la présence d'une
charge dans un espace.
Une représentation courante de ce champ vectoriel est le dessin de vecteurs à intervalles réguliers autour de la charge.
Contrairement à la réalité, nous utilisons un espace en 2 dimensions. Cet espace contient les charges ainsi que les lignes de champs. Il est limité à un carré de [0, 1]x[0, 1] ce qui signifie que tout objet dépassant cette limite ne sera pas calculé. Cela nous permet de concentrer les calculs dans cet espace qui sera ensuite affiché. Pour afficher cet espace qui ne contient que des valeur thérorique, nous convertissons les positions en fonction de la taille de l'écran.
Une autre représentation est celle des lignes de champ.
C'est autour de cette dernière que se construit ce projet.
![source: https://commons.wikimedia.org/w/index.php?curid=1044851](E_FieldOnePointCharge.png){width="28%"}\ ![source: https://brilliant.org/wiki/electric-field-lines/](fieldlines.jpg){width="72%"}
## Buts
Le but premier de ce projet est de créer un outil de visualisation de
champs électriques pour en faciliter la compréhension.
Il permet d'observer les effets de différents paramètres
(charge, distance, etc.) sur la "forme" du champ.
On peut facilement imaginer réutiliser cet outil dans un autre projet
de simulation, plus complexe.
# Plan
1. **Théorie**:
2. **Méthodologie**
3. **Implémentation**
4. **Résultats**
5. **Conclusion**
# Théorie
## Charge électrique
La charge électrique peut être comprise comme le déséquilibre entre le
nombre de protons et d'électrons dans un corps.
Une conséquence de ce fait est l'existance d'une charge élémentaire,
qui ne peut pas être divisée en charge non-nulle d'intensité moindre:
la charge d'un seul électron.
Un corps contenant plus d'électrons que de protons aura une charge
dite négative et un corps contenant plus de protons que d'électrons
aura une charge dite positive.
Tout corps chargé aura tendance à retourner à un état neutre
pour autant qu'il soit à proximité d'une charge opposée
avec laquelle il a la possibilité d'échanger des électrons.
L'unité de la charge électrique est le Coulomb $[C]$.
## Champ électrique
Le champ électrique étant un _champ vectoriel_,
sa représentation exacte nécessiterait, une infinité de vecteurs:
un pour chaque point de l'espace.
Le champ électrique d'une charge en un point de l'espace est l'effet
que la charge aura en ce point.
Celui-ci est représentable sous la forme d'un vecteur unique.
Comme dans le cas d'une force résultante, plusieurs charges
produiront en un point donné une valeur de _champ résultant_,
étant la somme vectorielle des champs de toutes les charges,
en ce point.
Tout objet chargé placé dans un champ électrique subira une force due à ce dernier.
L'intensité de cette force est le produit du champ à la position de l'objet
et de la charge de l'objet.
L'expression du champ électrique $\overrightarrow{E}$
d'une charge $Q$ placée à la position $\overrightarrow{p}$,
au point $\overrightarrow{x}$
est la suivante:
$$ \overrightarrow{E_x} = K * \frac{Q}{{|\overrightarrow{x} - \overrightarrow{p}|}^2} * \frac{\overrightarrow{x} - \overrightarrow{p}}{|\overrightarrow{x} - \overrightarrow{p}|} $$
Le but du travail, est avant tout de faciliter la compréhension des champs électriques. Avoir une aide visuelle permet de mieux se rendre compte du fonctionnement de celles-ci. Il est aussi possible de s'en servir au sein d'autres projet permettant de simulé quelque chose qui serait influencé par les champs électriques.§
Chapitres:
- Méthodologie: Une description du travail permet de mieux comprendre ça réalisation, ainsi que la méthodologie que nous avons utilisé pour y arriver contenant aussi des rappels théoriques.
- Résultats: Les résultats du programme sont aussi disponibles plus bas.
- Conclusion: Conclusion et résumé du travail.
# Méthodologie
Le programme peut se décomposer en plusieurs sections. La section d'affichage primaire, qui permet d'afficher des lignes ou des cercles, qui seront utilisés plus tard pour afficher des résultats plus complexes. La section de calculs physique, qui permet de calculer la force des champs à une certaine position dans notre espace. Puis finalement les fonctions qui se servent des deux sections précédentes afin d'afficher les charges ainsi que les lignes de champs.
## Espace de simulation
Contrairement à la réalité, nous évoluons dans un espace en 2 dimensions.
Celui-ci est limité à un carré de [0, 1]x[0, 1],
ce qui signifie que tout objet dépassant cette limite
ne sera pas calculé.
Cet espace contiendra les charges ainsi que les lignes de champ.
Cela nous permet de borner le nombre de calculs réalisés.
Pour afficher les objets de cet espace, nous représentons
les positions de notre carré comme des proportions de la
taille de l'écran.
Affichage:
```c
typedef struct
{
uint32_t row;
uint32_t column;
} coordinates_t;
## Dessin des lignes de champ
void gfx_draw_line(struct gfx_context_t *ctxt, coordinates_t p0, coordinates_t p1, uint32_t color);
Une ligne de champ nous permet de visualiser le champ électrique
généré par les charges.
Dans notre cas, nous prenons une position aléatoire dans notre espace,
suffisamment éloignée de toute charge, et calculons
la valeur du champ électrique en ce point.
Cela nous donne une direction, que nous suivons dans les deux sens
pour dessiner la ligne, jusqu'à atteindre une charge ou
sortir du carré.
Le résultat de ce processus nous donne une ligne de champ unique.
Il suffit de répéter ces étapes jusqu'à ce que l'on juge le nombre
de lignes suffisant.
void gfx_draw_circle(struct gfx_context_t *ctxt, coordinates_t c, uint32_t r, uint32_t color);
```
Physique:
# Implémentation
Le programme peut se décomposer en plusieurs sections. La section d'affichage primaire, qui permet d'afficher des lignes ou des cercles, qui seront utilisés plus tard pour afficher des résultats plus complexes. La section de calculs physique, qui permet de calculer les champs à une certaine position dans notre espace. Puis finalement les fonctions qui se servent des deux sections précédentes afin d'afficher les charges et les lignes de champs.
## Dessin de formes géométriques
Celui-ci permettant de tester et d'utiliser toutes les autres fonctionnalités
du projet, il paraîssait sage de commencer par implémenter des
fonctions d'affichage de lignes et de cercles.
```c
bool compute_e(charge_t c, vec2 p, double eps, vec2 *e);
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);
```
## Calcul de grandeurs physiques
Ensuite, nous avons écrit les fonctions de calcul de champ électrique
en un point.
```c
bool compute_total_normalized_e(charge_t *charges, int num_charges, vec2 p,
double eps, vec2 *e);
bool compute_e(charge_t c, vec2 p, double eps, vec2 *e);
bool compute_total_normalized_e(charge_t *charges,
int num_charges,
vec2 p,
double eps,
vec2 *e);
```
$$
P_{suivant} = P + \sum_{i}^n E_i * \frac{\overrightarrow{qiP}}{||\overrightarrow{qiP}||}
$$
## Affichage des charges et des lignes de champ
Finalement, nous avons implémenté l'affichage des charges et d'une ligne de champ
passant par un point donné.
$$ P_{suivant} = P + \sum_{i}^n E_i * \frac{\overrightarrow{qiP}}{||\overrightarrow{qiP}||} $$
$$
P_{suivant} = P + \delta x * \frac{\overrightarrow{E}}{||\overrightarrow{E}||}
$$
$$ P_{suivant} = P + \delta x * \frac{\overrightarrow{E}}{||\overrightarrow{E}||} $$
$$
\delta x = \frac{1}{\sqrt{powlargeur^2 + hauteur^2}}
$$
$$ \delta x = \frac{1}{\sqrt{powlargeur^2 + hauteur^2}} $$
$$
\overrightarrow{E} = \sum_{i}^n E_i * \frac{\overrightarrow{qiP}}{||\overrightarrow{qiP}||}
$$
$$ \overrightarrow{E} = \sum_{i}^n E_i * \frac{\overrightarrow{qiP}}{||\overrightarrow{qiP}||} $$
$$
P = P_{suivant}
$$
$$ P = P_{suivant} $$
$$
P_{suivant} = P - \delta x * \frac{\overrightarrow{E}}{||\overrightarrow{E}||}
$$
$$ P_{suivant} = P - \delta x * \frac{\overrightarrow{E}}{||\overrightarrow{E}||} $$
Final:
```c
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);
static void draw_charges(struct gfx_context_t *context,
charge_t *charges,
int num_charges,
double x0,
double x1,
double y0,
double y1);
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);
```
## Logique principale de haut niveau
Dans un premier temps nous créons des charges et les
positionnons dans l'espace de simulation.
Nous dessinons ensuite les lignes de champ dans cet espace,
ce qui nous permet de visualiser les champs électriques.
```c
static void draw_charges(struct gfx_context_t *context, charge_t *charges,
int num_charges, double x0, double x1, double y0, double y1);
charge_t charges[NC];
for (int i = 0; i < NC; ++i)
charges[i] = charge_create(
i % 2 == 0 ? rand_one() : -rand_one(),
vec2_create(rand_one(), rand_one())
);
struct gfx_context_t *ctxt = gfx_create("elec", WID, HEI);
draw_everything(ctxt, charges, NC, NLINES, DX, 0.0, 1.0, 0.0, 1.0);
gfx_present(ctxt);
while (gfx_keypressed() != SDLK_ESCAPE) {
gfx_present(ctxt);
}
gfx_destroy(ctxt);
```
D'autres sections ont servient mais n'on pas été créé pour ce projet en particulier. On peut retrouver la librairie gfx qui permet tout l'affichage, ainsi que vec2 qui nous est utile pour les calculs de vecteurs dans notre espace. Et finalement utils qui nous permet avant tout à convertir nos vecteur théoriques en coordonnées utilisables par l'affichage.
Afin de travailler plus éfficacement, nous nous sommes partager la charge de travail, pendant que l'un travaillait sur les fonctions `d'affichage`, l'autres commencait à écrire les fonctions de calculs `physiques`. Cela nous a permit de travailler en parralèle et d'avancer plus vite le projet. Terminer les fonctions d'affichage rapidement étant très important afin de pouvoir visualiser le résultat des calculs. Lorsque l'affichage était fini et la première partie des calculs aussi, nous nous sommes concentré ensemble sur la partie `finale` qui consiste à afficher les lignes de champs. Lorsque le travail nous a semblé terminé, nous nous sommes penché sur l'optimisation du code.
# Résultats
Voici un exemple de résultat que nous avons observé avec notre programme (Figure 1), on peut y observer les charges électriques, chargée différement, ainsi que les lignes de champs. On voit très rapidement que les lignes partent d'une charge et se dirige vers l'autre. C'est le résultat attendu dans ce cas. Maintenant si nous augmentons la puissance d'une des charges, on souhaite voir que celle-ci a un plus gros impacte sur le champ électrique que l'autre charge. C'est bien le cas comme on peut l'observer (Figure 2) et on peut vérifier la même chose en le faisant dans l'autre sense(Figure 3).
<table>
<tbody>
<tr>
<td>Figure 1</td>
<td>Figure 2</td>
<td>Figure 3</td>
</tr>
<tr>
<td><img src="./2_charges.png" alt="step_1" width="400"/></td>
<td><img src="./2_charges_+Intensity.png" alt="step_2" width="400"/></td>
<td><img src="./2_charges_-Intensity.png" alt="step_2" width="400"/></td>
</tr>
</tbody>
</table>
Pour s'assurer du bon fonctionnement de notre programme, nous avons décidé d'ajouter plusieurs charges afin de vérifier que le champ se comporte de manière cohérente. Comme on peut le voir (Figure 4), les lignes de champs sont correctement impactées par les charges ainsi que par leur intensité.
<table>
<tbody>
<tr>
<td>Figure 4</td>
</tr>
<tr>
<td><img src="./3_charges.png" alt="step_1" width="500"/></td>
</tr>
</tbody>
</table>
En plus de ces tests de logiques, nous avons une batterie de test permettant de vérifier que différentes parties du programme fonctionnent. Dans le cas des fonctions qui s'occupent de la physique, nous avons réalisé des tests unitaires en controlant les données reçu en fonction des données fournies à nos méthodes. Nous n'avons cependant pas eux le temps de rendre ces tests complètement séparé du reste du code (Moq). Il est aussi possible que certains de ces tests ne contrôles pas toutes les possibilités, ils restent cependant utiles afin de vérifier le fonctionnement du code d'ordre général. Pour l'affichage, il s'agit aussi d'un test visuel. Nous déssinnons divers traits ainsi qu'un cercle et vérifions si l'affichage correspont à ce que l'on souhaite. Dans notre cas, un cercle et de multiples traits partant dans toutes les directions(Figure 5).
<table>
<tbody>
<tr>
<td>Figure 5</td>
</tr>
<tr>
<td><img src="./draw_test.png" alt="step_1" width="100"/></td>
</tr>
</tbody>
</table>
Voici un aperçu de résultats que nous avons observés avec
notre programme.
Notons que les charges électriques sont de signes opposés.
On voit très rapidement que les lignes de champ relient les charges.
Cela est effectivement le résultat attendu dans ce cas de figure.
Maintenant si nous augmentons la valeur absolue d'une des charges,
on remarque que celle-ci a un impact plus important sur le champ
électrique total que l'autre charge.
![](2_charges.png){width="33%"}\ ![](2_charges_+Intensity.png){width="33%"}\ ![](2_charges_-Intensity.png){width="33%"}
La série de tests s'est poursuivie par la vérification du
comportement du modèle lorsque l'on ajoutait un nombre de charges
plus grand que 2 dans l'espace.
Le résultat affiché semble cohérent.
![3 charges](3_charges.png){width="50%"}
En plus de ces tests s'appliquant au modèle physique,
nous avons une batterie de tests permettant de se convaincre de façon
non exhaustive que les différentes fonctions aient un comportement adéquat.
Dans le cas des fonctions de calcul de grandeurs physiques,
nous avons réalisé des tests unitaires.
Pour l'affichage, le test est visuel et nécessite un bref contrôle humain.
Le rôle de ces tests est de former un premier filtre face aux bugs éventuels.
![draw test](draw_test.png){width="35%"}
# Conclusion
Au cours de ce projet nous avons pu observer la "forme"
du champ électrique dans un espace contenant plusieures charges.
Cela nous permettrait de visualiser, par exemple, la direction du
vecteur accélération d'une charge mobile qui se retrouverait
dans cet environnement.
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment