TECHNOLOGIE
Projet Scratch
Simulateur de propagation d'épidémie
Pierre Huguet de l’association "On va essayer" propose une simulation de la propagation d’une épidémie.
Il explique ce qu’est un modèle scientifique et son intérêt. Il fait fonctionner ce modèle avec Scratch, le célèbre logiciel de programmation graphique abordable par toutes et tous.
Cette modélisation avec Scratch permet de visualiser les mécanismes d'une épidémie.
C’est un simulateur très simple à vocation pédagogique. Il ne permet aucune prévision quantitative.
Extrait de la vidéo de présentation du projet de Pierre Huguet :
Si tu souhaites voir le projet complet de Pierre Huguet : http://onvaessayer.org/scratch/epidemy/epidemyV0.php
Objectif de ton projet
Ecrire et exécuter un programme avec Scratch permettant de simuler la propagation d'une épidémie
Cette simulation s'appuiera sur le projet de Pierre Huguet mais restera plus simple.
Pour réussir ce projet, suis les étapes proposées l'une après l'autre.
Etape 0 - Démarrer le projet
Pour démarrer correctement :
-
Ouvrir le projet avec la version de Scratch en ligne
-
Sauvegarder le projet sur ton ordinateur
-
Comprendre l'environnement Scratch
-
Comprendre le projet de départ
La sauvegarde se fait
dans le dossier "Téléchargement"
sous le nom "Simulateur épidémie - v0"
Remarque :
Lorsque tu souhaites reprendre le travail avec le fichier que tus as enregistré sur ton ordinateur, tu n'es pas obligé d'ouvrir le projet de départ :
-
Lance Scratch en ligne
Puis clique sur "Commencer à créer"
-
Charge ton fichier
Commande "Load from your computer"
N'oublie pas de changer la langue en français
(menu "Globe" à gauche de "Fichier")
Pense à sauvegarder régulièrement
2
Clique ici pour ouvrir le projet Scratch
1
Un nouvel onglet s'ouvre dans le navigateur
Clique sur
"Voir à l'intérieur" pour lancer l'édition du programme
2
1
Plus d'explications sur l'environnement Scratch
Ces deux vidéo présente la version 2 de Scratch.
Le principe reste identique
Ajouter un lutin et faire son 1er programme
Vocabulaire sur l'environnement de Scratch
Clique sur l'image pour l'agrandir
3
4
Ce projet de départ contient un seul lutin appelé "Personne". Ce lutin représente un individu qui pourra se déplacer dans la scène.
Trois costumes lui sont attribués :
-
CostumeBonneSanté
-
CostumeMalade
-
CostumeGuéri
L'onglet "Costume" permet de voir ces trois costumes.
Mais il ne faut pas les modifier.
Il est donc préférable pour la suite du projet, de rester toujours sur l'onglet "Code".
Etape 1 - Créer la population
Un sous-programme est un bloc d’instructions réalisant une certaine tâche. Il possède un nom et est exécuté lorsqu'il est appelé.
Un script bien structuré contiendra un programme dit principal, et plusieurs sous-programmes dédiés à des fonctionnalités spécifiques.
Quand le programme principal fait appel à un sous–programme, il suspend son propre déroulement, exécute le sous–programme, et reprend ensuite son fonctionnement.
1
Avantage sur l'utilisation de sous programme :
-
Simplifier l'apparence et la longueur du script en évitant la duplication de code
-
Améliorer la conception du script en réduisant la complexité par un découpage des tâches
On considère ici une population d'une centaine de personnes. Cette population peut représenter les habitants d'une ville ou d'un pays.
Tu dois compléter le programme principal pour :
-
"Créer un clone de moi même", instruction qui permet de copier une image du lutin
-
répéter 100 fois cette instruction
Tu dois créer un bloc d'instruction qui permet de :
-
positionner le clone aléatoirement (au hasard)
-
lui donner le costume "CostumeBonneSanté
L'exécution de ce bloc sera lancé par l'événement "Quand je commence comme un clone"
(événement qui ce trouve dans la bibliothèque "Contrôle")
3
La notion de variable
4
Dans ce projet, tu vas avoir besoin de connaitre l'état de chaque clone, pour pouvoir par exemple comptabiliser le nombre de malade ou de personne saine.
Pour cela tu dois créer une variable appelée "Santé".
Tu dois modifier le script pour affecter la variable "Santé" avec une valeur adaptée à chaque modification de costume.
Pour créer la population :
-
Comprendre la notion de bloc (sous programme)
-
Créer le patient 0
-
Créer une centaine de personnes
-
Comprendre la notion de variable
Remarque
Le nom de la variable et sa valeur apparaissent dans la scène si cette variable est coché dans la liste des variables.
Dans ce projet il est inutile de faire apparaître la variable "Santé".
On considère ici qu’une épidémie démarre avec un premier malade qui pourra contaminer les personnes avec qui il sera en contact.
Tu dois créer un bloc (un sous-programme) appelé "Patient 0" qui réalisera les actions suivantes :
-
positionner le lutin "Personne" au centre de la scène
-
mettre à ce lutin le costume "CostumeMalade"
2
Il est conseillé avant de lancer l'exécution de cliquer sur le bouton "Stop" qui permet d'initialiser la scène
On peut vérifier l'exécution du programme dans la scène en cliquant sur le bouton "Commencer"
Etape 2 - Déplacer la population
1
La centaine de clone, ainsi que le patient 0, doivent se déplacer de façon aléatoire dans la scène. Si un clone arrive sur un bord de la scène alors il doit "rebondir" pour rester à l'intérieur.
Cette façon de déplacer les clones permet de simuler, par exemple, le déplacement d'une population d'une ville à l'intérieur de cette ville.
Pour déplacer la population :
-
Comprendre le principe de déplacement
-
Comprendre la solution logicielle retenue
-
Modifier et compléter le programme
Ce déplacement élémentaire ainsi que le "rebond" si un bord de scène est touché seront exécutés dans un bloc sous-programme appelé "Bouger".
Remarque :
L'explication qui suit est donnée pour le lutin "Personne".
Mais il faut bien comprendre que toutes les actions effectuées sur ce lutin "Personne" se feront aussi sur chaque clone.
Explication :
Le déplacement du lutin va être cadencé par une "horloge" :
-> à chaque "top" d'horloge, le lutin tournera sur une position aléatoire et se déplacera de 3 pas.
Une instruction de Scratch (bibliothèque événement) permet d'envoyer un message à "tout le monde" (au lutin et donc aux clones). Cette instruction réalisera le "top horloge". Elle sera exécutée plusieurs fois dans le programme principal.
Une répétition de 480 fois sera choisi.
Une autre instruction de Scratch (bibliothèque événement) permet de lancer une suite d'instructions lorsqu'un message est reçu. Cette instruction permettra donc de lancer l'exécution d'un déplacement élémentaire (direction aléatoire + déplacement de 3 pas).
2
3
Etape 3 - Propager l'épidémie
Pour propager l'épidémie :
-
Comprendre le principe de propagation
-
Comprendre la solution logicielle retenue
-
Modifier et compléter le programme
1
Lors de cette étape, on s'intéresse uniquement à la propagation de l'épidémie. La guérison d'une personne se fera à l'étape suivante.
On considère ici qu’une épidémie démarre avec un premier malade qui peut contaminer les personnes avec qui il est en contact.
Lorsqu'une personne saine entre en contact avec une personne malade, alors elle devient à son tour malade.
Remarque :
L'explication qui suit est donnée pour le lutin "Personne".
Mais il faut bien comprendre que toutes les actions effectuées sur ce lutin "Personne" se feront aussi sur chaque clone.
Explication :
Pour détecter le contact entre deux clones, un test sera fait sur le contact avec la couleur orange (couleur du costume "CostumeMalade") :
Si la couleur orange est touchée
Alors Basculer le costume sur "CostumeMalade" et Mettre la variable "Santé" à "malade"
Ce test sera exécuté dans un bloc sous-programme nommé "Tester-bonne-santé".
Ce bloc sous-programme "Tester-bonne-santé" sera lancé après l'appel du sous-programme "Bouger" uniquement si la variable "Santé" du lutin est égale à "bonneSanté".
Il est en effet inutile de lancer le sous-programme "Tester-bonne-santé" si le lutin est déjà malade.
Remarque sur l'instruction "couleur touchée ?" de Scratch
Cette instruction renvoie une valeur logique : Vrai ou Faux
Il est absolument indispensable de régler la couleur à la véritable couleur orange du costume "CostumeMalade" :
Clique sur la couleur pour la modifier
Clique sur la pipette pour récupérer une couleur
Clique au milieu du "patient 0" pour récupérer la véritable couleur
2
3
Etape 4 - Guérir les personnes
Pour guérir les personnes :
-
Comprendre le principe de guérison
-
Comprendre la solution logicielle retenue
-
Modifier et compléter le programme
1
Lorsqu'une personne saine entre en contact avec une personne malade, elle est alors contaminée et devient à son tour malade.
On suppose ici que toute personne atteinte par la maladie peut en guérir au bout d'un certain temps.
La personne alors guérie est immunisée contre la maladie et ne peut donc plus contaminer d'autre personne.
2
Remarque :
L'explication qui suit est donnée pour le lutin "Personne".
Mais il faut bien comprendre que toutes les actions effectuées sur ce lutin "Personne" se feront aussi sur chaque clone.
Explication :
Pour connaitre depuis combien de temps le lutin est malade, il faut utiliser une variable locale au lutin. On appellera cette variable : "temps-depuis-contamination".
Lorsque un lutin en bonne santé est contaminé, alors il devient malade. Sa variable "Santé" est alors affectée à la valeur "malade". Il faudra aussi à ce moment initialiser la variable "temps-depuis-contamination" c'est à dire la mettre à zéro.
Cette variable "temps-depuis-contamination" doit aussi être initialisée pour le patient 0.
(donc dans le bloc sous-programme "Patient 0")
A chaque top d'horloge la variable "temps-depuis-contamination" devra être incrémentée c'est à dire qu'il faudra ajouter 1 à sa valeur.
Il faudra ensuite tester la valeur de la variable "temps-depuis-contamination" à la valeur du temps de guérison que l'on se sera fixé. On prendra ici 100 pour cette durée de guérison.
On aura donc le test suivant :
Si "temps-depuis-contamination" est supérieur à 100
Alors Basculer le costume sur "CostumeGuéri" et Mettre la variable "Santé" à "guéri"
L'incrémentation (ajouter 1) de la variable "temps-depuis-contamination" ainsi que ce test seront exécuté dans un bloc sous-programme nommé "Tester-contaminé".
Ce bloc sous-programme "Tester-contaminé" sera lancé dans l'événement "Quand je reçois top horloge" uniquement si la variable "Santé" du lutin est égale à "malade".
Il est en effet inutile de lancer le sous-programme "Tester-contaminé" si le lutin n'est pas malade.
Remarque sur la création de la variable "temps-depuis-contamination"
Pour créer cette variable voir la partie 4 de l'étape 1 avec :
-
nom de la variable : temps-depuis-contamination
-
case à cocher : Pour ce sprite uniquement
3
Etape 5 - Comptabiliser les malades
1
Lors de la simulation, on souhaite comptabiliser le nombre de malade de deux façons :
-
Le nombre actuel de malade
Lorsqu'une personne devient malade alors on ajoute 1 à ce nombre. Si une personne guérit on soustrait 1.
-
Le nombre total de malade
Lorsqu'une personne devient malade alors on ajoute 1 à ce nombre. Si une personne guérit le nombre n'est pas modifié.
Pour comptabiliser les malades :
-
Comprendre le principe du comptage
-
Comprendre la solution logicielle retenue
-
Modifier et compléter le programme
2
Création des variables
Deux variables seront créées :
-
"Nombre de malade"
-
"Nombre total de malade"
Pour créer ces deux variables voir la partie 4 de l'étape 1. Pour les deux variables il faudra cocher la case "Pour tous les sprites".
Initialisation des variables
Ces deux variables devront être initialisées, c'est à dire qu'il faut leur donner la valeur 0.
Cette initialisation doit se faire en tout début de programme, à la suite de l'événement "Quand le drapeau vert est cliqué".
Modification des variables
-
Variable "Nombre de malade"
Chaque fois qu'un clone devient malade il faut incrémenter
cette variable c'est à dire lui ajouter 1 à sa valeur.
L'instruction suivante doit être utilisée :
Attention, il ne faut pas oublier le patient 0.
Chaque fois qu'un clone est guéri il faut décrémenter
cette variable c'est à dire lui retirer 1 à sa valeur.
L'instruction suivante doit être utilisée :
-
Variable "Nombre total de malade"
Chaque fois qu'un clone devient malade il faut incrémenter
cette variable c'est à dire lui ajouter 1 à sa valeur.
Attention, il ne faut pas oublier le patient 0.
Affichage des variables
Les valeurs de ces deux variables doivent être affichées dans la scène.
Voir la remarque de l'étape 1.
3
A toi de réfléchir
Etape 6 - Afficher le nombre maximal de malades
Pour afficher le nombre maximal de malades :
-
Comprendre le principe du nombre maximal
-
Comprendre la solution logicielle retenue
-
Modifier et compléter le programme
On souhaite comptabiliser et afficher le nombre maximum de personnes malades en même temps.
Ce nombre maximum est une information importante car c'est ce nombre qui peut saturer les capacités hospitalière.
1
2
Création de la variable
Une variable doit être créée :
-
"Nombre Max de malade"
Pour créer cette variable voir la partie 4 de l'étape 1. Pour cette variable il faudra cocher la case "Pour tous les sprites".
Initialisation de la variable
Cette variable doit être initialisée, c'est à dire qu'il faut lui donner la valeur 0.
Cette initialisation doit se faire en tout début de programme, à la suite de l'événement "Quand le drapeau vert est cliqué".
Modification de la variable
La variable "Nombre de malade" correspond au nombre de malade à chaque instant. Suivant les simulations, ce nombre augmente en partant de 1 puis diminue. La valeur de la variable "Nombre Max de malade" doit suivre ce nombre mais elle doit garder la valeur maximale atteinte lorsque le nombre de malade diminue.
Solution logicielle possible :
Chaque fois qu'un clone devient malade (lorsqu'il touche la couleur orange) il faut comparer les deux variables "Nombre de malade" et "Nombre Max de malade".
Si "Nombre de malade" > "Nombre Max de malade"
Alors il faut affecter à la variable "Nombre Max de malade" la valeur de la variable "Nombre de malade"
Lorsqu'un clone guéri alors le nombre de malade diminue, il n'y a donc aucune modification à apporter à la variable "Nombre Max de malade".
Affichage de la variable
La valeur de cette variable doit être affichée dans la scène.
Voir la remarque de l'étape 1.
3
A toi de réfléchir
Etape 7 - Confiner les malades
Pour confiner les malades :
-
Comprendre le principe du confinement
-
Comprendre la solution logicielle retenue
-
Modifier et compléter le programme
Une personne contaminée peut être détectée à partir d'un certain temps (apparition de symptômes puis détection par des analyses). La personne détectée doit alors être confinée. Dans le simulateur le confinement se traduit par un arrêt de déplacement de la personne. En revanche les personnes saines continuent de se déplacer et peuvent entrer en contact avec une personne confinée.
1
2
Remarque :
L'explication qui suit est donnée pour le lutin "Personne".
Mais il faut bien comprendre que toutes les actions effectuées sur ce lutin "Personne" se feront aussi sur chaque clone.
Explication :
Le lutin "Personne" (donc chaque clone) doit avoir une variable supplémentaire appelée "confiné".
Cette variable doit être créée uniquement pour le lutin "Personne".
Cette variable "confiné" pourra avoir deux valeurs possibles : "oui" et "non" (c'est donc une variable logique).
La valeur de cette variable permettra de conditionner le déplacement du lutin dans le bloc sous-programme "Bouger".
Remarque sur la création de la variable "confiné"
Pour créer cette variable voir la partie 4 de l'étape 1 avec :
-
nom de la variable : confiné
-
case à cocher : Pour ce sprite uniquement
Lorsqu'une personne guérit, elle ne doit plus être confinée. Il faut donc affecter la valeur "non" à la variable "confiné".
L'instruction ci-contre doit donc être ajoutée dans le bloc sous-programme "Tester-contaminé" au bon endroit.
Le confinement d'une personne doit se faire lorsqu'elle est contaminée depuis un certain délai. Ce délai sera fixé par une nouvelle variable nommée "Détection". Cette variable doit être commune à tous les lutins (clones).
Cette variable "confiné" doit être initialisée à la valeur "non" dans le bloc "Quand je commence comme un clone".
Cette variable "confiné" doit aussi être initialisée à la valeur "non" dans le bloc sous-programme "Patient 0".
En effet le patient 0 ne doit pas être confiné dès le début puisqu'il n'a pas encore été détecté.
Remarque sur la création de la variable "Détection"
Pour créer cette variable voir la partie 4 de l'étape 1 avec :
-
nom de la variable : Détection
-
case à cocher : Pour tous les sprites
La variable "temps-depuis-contamination" (déjà créée) donne une information sur la durée de contamination du lutin "Personne". Pour savoir si l'on doit confiner le lutin il suffit de comparer la valeur de la variable "temps-depuis-contamination" à la valeur de la variable "Détection".
On aura donc le test et son action associée suivant :
Si "temps-depuis-contamination" est supérieur à "Détection"
Alors mettre "confiné" à "oui"
Ce test et son action associée sera placé dans le bloc sous-programme "Tester-contaminé" juste avant le test sur la guérison.
Remarque sur la variable "Détection" :
La variable "Détection" sera initialisée à partir de la scène. Pour cela il faut :
-
Afficher la variable dans la scène
-
Sélectionner le mode "Barre de défilement"
-
Modifier l'intervalle du curseur
Pour afficher des variables dans la scène, il suffit de les cocher dans la liste de variable.
Cocher la variable "Détection".
Cocher aussi les variables :
-
"Nombre Max de malade"
-
"Nombre total de malade"
Il est inutile d'afficher les autres variables
1
Clic droit sur la variable affichée dans la scène puis sélectionner "barre de défilement"
2
3
Clic droit sur le curseur puis sélectionner "change slider range".
Modifier alors les valeurs extrêmes du curseur :
-
minimum :1
-
maximum : 100
3
A toi de réfléchir