Simuler un gaz avec Pyxel
Construire pas à pas avec Pyxel la simulation d’un gaz : chaque particule est un tuple, le gaz est une liste de tuples passée en paramètre aux fonctions.
Dans un gaz, les particules avancent en ligne droite et rebondissent sur les parois comme la bille sur la bande. Le programme de départ est fourni dans Capytale. Quand une question commence par « Sans exécuter le programme », on écrit sa réponse avant de vérifier.
Une particule décrite par un tuple
Une particule est décrite par cinq entiers, rangés dans un tuple, toujours dans le même ordre :
| indice | 0 | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
| élément | x |
y |
vx |
vy |
couleur |
x et y sont les coordonnées du centre, en pixels. vx et vy sont les nombres de pixels parcourus horizontalement et verticalement à chaque image. Un écran n’a pas de demi-pixel : toutes ces valeurs sont des entiers.
La ligne Particule = tuple[...] donne un nom au type d’une particule, que l’on utilise dans les annotations des fonctions.
pyxel.run attend deux fonctions sans paramètre. lambda: update(particules) est justement une fonction sans paramètre, écrite sur une ligne : à chaque image, elle appelle update en lui passant la liste particules.
Une fonction peut lire les constantes, écrites en majuscules (LARGEUR, RAYON…), car leur valeur ne change jamais. Elle ne lit aucune autre variable du programme principal : la liste des particules lui est toujours passée en paramètre.
Lancer le programme. Avec particules = [(36, 60, 2, -1, 8)] :
- que vaut
particules[0][2]? Quelle grandeur représente-t-il ? - que faut-il écrire pour obtenir la couleur de la particule ?
- la particule va-t-elle monter ou descendre quand elle bougera ? Justifier à l’aide du repère de Pyxel (Doc. 2,5).
Modifier particules pour obtenir une particule verte (couleur 11), au centre de l’écran, qui se déplacera vers la gauche de 1 pixel par image. Vérifier, puis revenir à la valeur de départ.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Une particule est décrite par le tuple (x, y, vx, vy, couleur). Avec particules = [(36, 60, 2, -1, 8)], que vaut particules[0][1] ?
particules[0] est le tuple de la particule, et son élément d’indice 1 est l’ordonnée y.
Dans Pyxel, une particule a vy = -1. Comment se déplace-t-elle verticalement ?
Dans Pyxel, augmente vers le bas : diminuer fait monter la particule.
D’après la règle du programme, quelles variables une fonction peut-elle lire sans les recevoir en paramètre ?
La valeur des constantes ne change jamais ; la liste des particules, elle, est toujours passée en paramètre.
Faire avancer la particule
Pyxel affiche 30 images par seconde et appelle update(particules) avant chaque image. À chaque appel, on ajoute vx à x et vy à y.
Sans exécuter le programme. La particule part de avec vx = 2. Elle touche le bord droit quand son centre atteint . Au bout de combien de temps ?
Un élève propose :
Sans exécuter le programme, prévoir ce qui se passe si on appelle deplacer(particules[0]). Expliquer.
La fonction doit donc fabriquer un nouveau tuple et le retourner. Pour récupérer d’un coup les cinq éléments de p, on le déballe :
Il faut autant de noms à gauche que d’éléments dans le tuple.
Écrire la fonction deplacer :
Tester dans la console : deplacer((36, 60, 2, -1, 8)) doit retourner (38, 59, 2, -1, 8).
Dans update, remplacer pass par gaz[0] = deplacer(gaz[0]). Sans exécuter le programme, prévoir ce qui se passera au bout de 2 secondes, puis vérifier.
Un autre élève écrit dans update : gaz = [deplacer(gaz[0])]. Il n’obtient aucune erreur, mais la particule reste immobile. Expliquer, en s’aidant des fonctions reinitialiser_1 et reinitialiser_2 du Doc. 3,2.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Que produit deplacer(particules[0]) si la fonction contient l’instruction p[0] = p[0] + p[2] ?
On ne peut pas modifier un élément d’un tuple : la fonction doit fabriquer et retourner un nouveau tuple.
Que retourne deplacer((36, 60, 2, -1, 8)) ?
On ajoute vx à x et vy à y : et . La vitesse et la couleur sont inchangées.
Dans update(gaz), laquelle de ces instructions fait réellement avancer la particule de la liste particules ?
gaz[0] = ... modifie un élément de la liste partagée avec le programme principal. gaz = [...] fait seulement référencer une nouvelle liste par la variable locale gaz.
À 30 images par seconde, une particule avance de 2 pixels par image. Combien de temps met-elle à parcourir 120 pixels ?
Sa vitesse vaut px/s, d’où s.
Rebondir contre les murs
Comme sur le billard, quand la particule touche le mur de droite, vx devient -vx. On complète deplacer : elle change d’abord la vitesse si un mur est touché, puis fait avancer la particule. Première version, qui ne traite que le mur de droite :
Compléter deplacer pour les murs de gauche, du haut et du bas, puis tester.
- Pour les murs du haut et du bas, quelle composante de la vitesse change de signe ?
- Le mur du haut est la ligne . Quel point du disque l’atteint en premier ?
Sans ordinateur. On part de particules = [(158, 60, 1, 0, 8)]. Compléter le tableau avec les valeurs de x et vx après chaque appel de update. Que fait la particule ? Vérifier à l’écran.
| image | départ | 1 | 2 | 3 | 4 |
|---|---|---|---|---|---|
x |
158 | ||||
vx |
1 |
Modifier les quatre conditions pour qu’une particule ne rebondisse que si elle se dirige vers le mur qu’elle touche. Refaire le tableau sans ordinateur, puis vérifier.
Un tuple n’est pas mutable : une fonction qui « modifie » une particule fabrique et retourne un nouveau tuple. Le déballage x, y, vx, vy, couleur = p donne un nom à chaque élément.
Lors d’un rebond sur une paroi, la composante de la vitesse perpendiculaire à la paroi change de signe.
Une fonction qui reçoit une liste en paramètre peut modifier ses éléments (gaz[0] = ...). Si elle affecte une nouvelle valeur au paramètre (gaz = ...), la liste d’origine ne change pas.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Une particule touche le mur du haut. Quelle composante de sa vitesse change de signe ?
Lors d’un rebond, la composante de la vitesse perpendiculaire à la paroi change de signe. Le mur du haut est horizontal.
Le disque a un rayon RAYON. Quelle condition indique qu’il touche le mur de gauche, d’abscisse 0 ?
Le point du disque le plus à gauche a pour abscisse x - RAYON : c’est lui qui atteint le mur en premier.
Pourquoi ajoute-t-on la condition vx > 0 au test du mur de droite ?
Sans elle, une particule qui vient de rebondir et touche encore le mur voit sa vitesse inversée une seconde fois : elle reste coincée contre la paroi.
Un gaz : une liste de particules
On veut maintenant 30 particules, tirées au hasard. pyxel.rndi(a, b) retourne un entier au hasard entre a et b, bornes comprises. Ajouter ces constantes au début du programme (8, 11 et 12 sont le rouge, le vert et le bleu) :
Écrire la fonction nouvelle_particule, puis la tester plusieurs fois dans la console :
- Un disque est entièrement visible si son centre est à au moins
RAYONpixels de chaque bord (Doc. 2,5). - Pour la couleur, tirer au hasard l’indice d’un élément de
COULEURS.
Dans le programme principal, remplacer particules = [(36, 60, 2, -1, 8)] par une liste de NB_PARTICULES particules construite en compréhension (Doc. 3,2). Pourquoi cette ligne doit-elle se trouver après la définition de nouvelle_particule ?
Modifier draw pour dessiner toutes les particules de gaz.
Pour faire bouger toutes les particules, un élève écrit :
Sans exécuter le programme, prévoir ce qu’on observe. Expliquer, puis corriger.
Le gaz est une liste de tuples, construite en compréhension. Pour lire ses éléments, on la parcourt par éléments. Pour les remplacer, on la parcourt par indices : gaz[i] = ....
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Quelle instruction construit une liste de NB_PARTICULES particules tirées au hasard ?
La compréhension appelle la fonction à chaque tour. La deuxième écriture répète NB_PARTICULES fois la même particule ; la troisième répète les éléments d’un seul tuple.
Que se passe-t-il avec la boucle for p in gaz: p = deplacer(p) ?
p = ... fait référencer un nouveau tuple par la variable p, mais rien n’est rangé dans la liste. Il faut parcourir les indices : gaz[i] = deplacer(gaz[i]).
Pour dessiner toutes les particules dans draw, quel parcours suffit ?
On ne modifie pas la liste : lire ses éléments un par un suffit.
Pour aller plus loin : des collisions entre particules
Dans un gaz réel, les particules se heurtent aussi entre elles. Deux particules se touchent si la distance entre leurs centres est inférieure ou égale à 2 * RAYON.
Ajouter from math import sqrt au début du programme, puis écrire :
Tester : distance((0, 0, 1, 1, 8), (3, 4, 0, 0, 12)) doit retourner 5.0.
Deux particules de même masse qui se heurtent de face échangent leurs vitesses. On adopte ce modèle pour toutes les collisions.
Écrire la fonction choc :
Tester : choc((50, 60, 1, 0, 8), (55, 60, -1, 0, 12)) doit retourner ((50, 60, -1, 0, 8), (55, 60, 1, 0, 12)).
Voici la fonction qui teste toutes les paires de particules de la liste gaz. Sa dernière ligne déballe le tuple retourné par choc, comme a, b = b, a (Doc. 3,1).
- Avec 3 particules, écrire tous les couples
(i, j)testés. - Pourquoi la boucle intérieure commence-t-elle à
i + 1et non à0?
Ajouter l’appel gerer_chocs(gaz) à la fin de update. Observer longuement : certaines particules restent collées. Pourquoi ? Corriger, en s’inspirant de la correction des rebonds sur les murs.
- Que fait
gerer_chocsà l’image qui suit un échange de vitesses ? - Sur le mur, on n’a fait rebondir que les particules qui s’en approchaient. Comment savoir si deux particules se rapprochent ? On peut utiliser
deplaceretdistance.
Il reste un défaut : des particules rapides se traversent parfois.
Sans ordinateur. Deux particules arrivent de face, en diagonale : (50, 50, 2, 2, 8) et (56, 56, -2, -2, 12). À chaque image, update les déplace, puis appelle gerer_chocs. Compléter le tableau (distances arrondies au dixième), puis expliquer pourquoi les particules se traversent.
| image | départ | 1 | 2 | 3 |
|---|---|---|---|---|
| particule 1 | (50, 50) | |||
| particule 2 | (56, 56) | |||
| distance | 8,5 | |||
se_touchent |
non | |||
se_rapprochent |
oui |
Pour éviter ce chevauchement, il faut anticiper : avant de déplacer les particules, on regarde si elles vont se toucher à l’image suivante.
Modifier la condition de gerer_chocs pour tester si les particules se toucheront après leur déplacement, puis placer l’appel gerer_chocs(gaz) au début de update. Refaire le tableau précédent, puis vérifier à l’écran que les particules ne se traversent presque plus.
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Avec 4 particules, combien de couples (i, j) la double boucle for i in range(n): for j in range(i + 1, n): teste-t-elle ?
(0, 1), (0, 2), (0, 3), (1, 2), (1, 3) et (2, 3) : chaque paire n’est testée qu’une fois.
Pourquoi la boucle intérieure commence-t-elle à i + 1 et non à 0 ?
En partant de 0, on testerait (0, 1) puis (1, 0). Il faut aussi éviter de tester une particule avec elle-même.
Que retourne choc((50, 60, 1, 0, 8), (55, 60, -1, 0, 12)) ?
Les particules échangent leurs vitesses ; elles gardent leur position et leur couleur.
Défis
Défi A : le mélange de deux gaz. Au départ, les particules rouges sont dans la moitié gauche de la boîte, les bleues dans la moitié droite. Donner à nouvelle_particule les paramètres couleur, x_min et x_max, puis construire la liste. Comparer la vitesse du mélange avec et sans collisions.
Défi B : chauffer le gaz. Chaque appui sur la touche ↑ double les deux composantes de la vitesse de toutes les particules. Que se passe-t-il après plusieurs appuis ?
Bilan
- représenter un objet par un tuple et lire un élément par son indice ;
- expliquer pourquoi on ne peut pas modifier un élément d’un tuple, et écrire une fonction qui retourne un nouveau tuple ;
- déballer un tuple pour nommer ses éléments ;
- construire une liste de tuples en compréhension ;
- choisir entre un parcours par éléments, pour lire une liste, et un parcours par indices, pour la modifier ;
- passer une liste en paramètre à une fonction, et expliquer pourquoi la fonction peut modifier ses éléments mais pas la remplacer ;
- parcourir toutes les paires d’éléments d’une liste avec deux boucles imbriquées ;
- faire tourner un programme à la main pour trouver l’origine d’un comportement inattendu.