Étiquette : SVT

Projets

Simulateur de transmission du covid-19

Vérifiez que vous respectez bien le protocole sanitaire avec ce simulateur. Il vous permettra de vous donner une idée sur votre civisme, votre exposition au coronavirus en espace clos ainsi qu’à visualiser les variables qui entrent en jeu dans ce processus de transmission.

Introduction

Ce projet a été réalisé par Iliess L., Luca B. et Romain B., élèves en première NSI en 2021/2022 au lycée Louis Pasteur.

Depuis près de deux ans, nous sommes en pleine pandémie. Cette pandémie a engendré un très grand nombre de morts. Pour éviter que d’autres gens ne meurent à cause du Covid-19 et sensibiliser, nous avons décidé de créer un simulateur de propagation de Covid-19 assez fiable. Malgré que cette histoire de virus relève de la biologie, sa transmission, elle, relève de la physique : la propagation d’aérosols (mini-gouttelettes en suspension dans l’air éjectées par une personne) ainsi une équation a pu être élaborée.

Ce programme permet de calculer le pourcentage de chance que quelqu’un se fasse contaminer par le Covid-19 dans un espace clos et plus précisément dans une salle de classe (d’environ 125 m³). Le résultat dépend du comportement de l’utilisateur ainsi chaque personne testant ce simulateur se sent un minimum concerné.

Nous demandons donc à l’utilisateur différentes informations sur la conduite d’un groupe de personnes dans un espace fermé notamment s’ils ouvrent beaucoup les fenêtres, si le port du masque est bien respecté, le temps passé dans la salle, le nombre de personne dans la salle et le débit d’air inspiré/expiré.

Le code

Le programme est composé de 5 fonctions et de 3 lignes de code. Les fonctions sont toutes dans le même genre, seuls les « prints », les variables et les valeurs changent.

Analysons une fonction :

La première partie de la fonction concerne les différents cas possibles.

def port_du_masque(): #savoir comment le masque est porté en classe, c'est une proportion
    print("1 - Dans votre classe, tout le monde porte bien le masque sur le nez et tout le temps.")
    print("2 - Il y en a quelques uns qui le mettent sous le nez.")
    print("3 - Tout le monde le porte tout le temps sous le nez.")
    print("4 - Personne ne le porte !")
    print()

Ensuite, nous utilisons une instruction conditionnelle pour permettre à l’utilisateur de choisir parmi les choix proposés et ainsi y associer une valeur correspondante au choix.

    choix = int(input("Veuillez selectionner votre choix:\t"))
    if choix == 1:
        F = 0.1
    elif choix == 2:
        F =  0.2
    elif choix == 3:
        F = 0.80
    elif choix == 4:
        F = 1

Et enfin une petite sécurité qui permet de vous renvoyez au début de la fonction si la réponse de l’utilisateur ne convient pas aux propositions.

    else:
        print()
        print("Votre choix n'est pas valide, veuillez taper 1, 2 ou 3 s'il vous plait.")
        print()
        port_du_masque()
    return F

4 des 5 fonctions sont exécutées dans une fonction globale. Cette fonction fait le plus gros du travail. Elle exécute toutes les autres fonctions, fait le calcul final de probabilité et compare le résultat de l’utilisateur aux normes de l’Etat.

Voici le calcul utilisé pour calculer la probabilité d’infection d’une personne.

print (" Dans votre classe, il y a",(nb_personne*t*Q**2*f**2*quantum)/(L*volume), "% de chance que quelqu'un soit infecté.")#calcul de la probabilité

Problèmes rencontrés

Le premier problème qu’on a pu rencontrer est le suivant : rendre une variable locale globale. La variable calculée dans la fonction était perdue si on ne la sauvegardait pas dans une nouvelle variable globale.

On a trouvé deux moyens de contrer ce problème :

Le premier est d’utiliser la fonction native « global ».

def temps_expo():#savoir le temps passé en classe en heure
    global t
    print("Combien de temps en heures passez-vous en classe en moyenne ? ")
    print()
    print("1 - entre 0 et 3 heures.")
    print("2 - entre 3 et 6 heures.")
    print("3 - entre 6 et 9 heures.")
    print()
    choix = int(input("Veuillez selectionner votre choix:\t"))
    if choix == 1:
        T = 2
    elif choix == 2:
        T = 5
    elif choix == 3:
        T = 8
    else:#permet de renvoyer au début de la fonction si le choix ne convient pas
        print()
        print("Votre choix n'est pas valide, veuillez taper 1, 2 ou 3 s'il vous plait.")
        print()
        temps_expo()
     t = T

Et le deuxième est d’exécuter la fonction directement dans la fonction globale et en même temps, assigner la valeur que la fonction renvoie à une nouvelle variable.

def proba_totale(): #probabilité d'infection
    print("------------------------------------------------------")
    print("|                       COVID                        |")
    print("------------------------------------------------------")
    t = temps_expo()

Le deuxième problème était : le « return » de la fonction qui ne marchait pas.

Pour résoudre ce problème, nous avons tout simplement décidé de remplacer le « return » par un « print ».

	print (" Dans votre classe, il y a",(nb_personne*t*Q**2*f**2*quantum)/(L*volume), "% de chance que quelqu'un soit infecté.")#calcul de la probabilité
    # return (nb_personne*t*Q**2*f**2*quantum)/(L*volume)

Conclusion

Ce simulateur permet de calculer la probabilité d’infection d’une personne dans un espace fermé par conséquent il peut permettre de faire réagir certaines personnes qui ne respectent pas les règles mises en place par le gouvernement : ce programme a aussi un objectif de sensibilisation.

En bas de la page, vous pourrez télécharger le programme.

Crédits

Toutes les informations et la formule utilisées proviennent de la chaine youtube Scienceetonnante tenu par David Louapre, un physicien et la vidéo d’où nous avons tiré toutes nos informations est inspirée des recherches de physiciens du MIT basé aux Etats-Unis : Bazant M. Z., & Bush J. W..

Projets

Une brève navigation dans l’espace sur python

Naviguez au cœur du système solaire, et découvrez les caractéristiques de chaque planètes qui le composent, soit, la période de révolution, la distance au soleil, la masse, le rayon et enfin les satellites connus (leur nombre) …

Ce projet est un programme réalisé sur python permettant de naviguer dans l’espace, et plus précisément dans notre système solaire. Il permet de découvrir les caractéristiques des planètes qui le compose, soit, la période de révolution, la distance au soleil, la masse, le rayon et enfin les satellites connus (nombre). Ce programme a été developpé sur omega et peut être téléchargeable sur la calculatrice Numworks via les liens hypertextes en bas de l’article.

Difficultés rencontrées…

À la genèse de notre projet, nous fûmes légèrement idéaliste quant à nos capacités, et à celles de la calculatrice ; nous voulions créer une animation, tel un court-métrage, avec l’histoire du big bang se déroulant sous nos yeux ébahis, puis la galaxie, et enfin atterrir dans notre système solaire, qui aurait été animé… Après un dur retour à la réalité, nous nous sommes accordées pour simplifier notre concept originel. Malgré avoir réalisé une deuxième couche graphique composée d’un trou noir ; Saggitarius A*, au centre de notre galaxie, et du système solaire, nous n’avons pu l’insérer dans le code initial.

Comment tout a commencé…

Notre programme a été conçu en deux grandes phases :

  • la couche graphique
  • l’interaction

La couche graphique

Premièrement, il a fallu tracer des cercles pour retrouver la forme des planètes, et insérer des dégradés afin de s’approcher au plus des couleurs initiales, en adoptant les modules mathkandinsky et random.Retour ligne automatique
Cette image a été le pilier de la création du fond graphique :

Pour ce faire, du à nos faibles connaissances en python, nous sommes allées nous renseigner auprès du célèbre Philippe Moutou.

def cercle(x0,y0,r,c,e):# fonction pour tracer contour du cercle
 for i in range(2*e):
   xd=x0-int((r-i*0.5)/sqrt(2))
   xf=x0+int((r-i*0.5)/sqrt(2))
   for x in range(xd,xf+1):
     x1=x
     y1=y0+int(sqrt((r-i*0.5)**2-(x-x0)**2))
     set_pixel(x,y1,c)
     for j in range(3):
       x2=x0+y1-y0
       y2=y0+x0-x1
       set_pixel(x2,y2,c)
       x1,y1=x2,y2
 
def cercle_plein(x0,y0,r,c1,e,c2): #remplir le cercle
 cercle(x0,y0,r,c1,e)
 cercle(x0,y0,r-e,c2,r-e)
 
def cercle_grade(x0,y0,R,c1,e,c2):#faire un dégradé de couleur
 for i in range(R):
   r=c1[0]+i*(c2[0]-c1[0])//R
   g=c1[1]+i*(c2[1]-c1[1])//R
   b=c1[2]+i*(c2[2]-c1[2])//R
   cercle(x0,y0,i,color(r,g,b),1)

Grâce à son génie, nous n’avons eu qu’à changer couleurs, rayons ou encore coordonnées dans les diverses fonctions, et créer des listes pour regrouper les différents globes, soit neuf au total en comptant l’astre qui nous fournit en énergie. Pour trouver les couleurs appropriées, nous nous sommes servies de code couleur html, afin de concevoir le plus précisément possible les textures.

Voici un exemple d’appel de fonction, qui a été fait pour chaque planète, et mis dans une liste pour simplifier le code :

cExt=[251,136,7]
cInt= [106,73,32]
cercle_grade(197,95,8,cExt,10,cInt)

Ensuite nous sommes passées à la conception du fond étoilé avec toujours l’aide de notre cher Moutou :

def degrade(c1,c2,k):
 dr=c2[0]-c1[0]
 dg=c2[1]-c1[1]
 db=c2[2]-c1[2]
 return color(c1[0]+int(k*dr),c1[1]+int(k*dg),c1[2]+int(k*db))
 
def tirage(n):
 for i in range(n):
   x=randint(0,320)
   y=randint(0,222)
   c=couleur(x,y)
   set_pixel(x,y,c)
   set_pixel(x+1,y,c)
   set_pixel(x,y+1,c)
   set_pixel(x+1,y+1,c)
 
def couleur(x,y):
 d=sqrt((x-160)**2+(y-111)**2)/32.5
 return degrade(c[int(d)],c[(int(d)+1)%6],d-int(d))

Il nous a suffit de changer les couleurs pour faire un magnifique dégradé galactique, et effectuer un tirage non exhaustif afin de révéler des points blancs.

c=[[235,128,0],[13,89,175],[13,89,175],[44,122,211],[207,230,230],[207,230,230]]
tirage(250)

Pour afficher les anneaux blancs qui représentent l’orbite de chaque planète, rien de plus simple, il suffit d’appeler la fonction traçant le contour d’un cercle.

Etant donné qu’il y a 8 planètes on se sert de la variable for in range :

c_blanc=[119,135,135]
r_orb = [22,32,42,52,62,76,92,109]
for i in range(8):
   cercle(160,111,r_orb[i],c_blanc,1)

Bien évidemment cet appel de fonction doit se faire après celui du fond étoilé, mais avant celui des planètes, pour que tout se superpose parfaitement.

Voici le résultat escompté après de maints efforts :

L’interactivité :

Méconnus du grand public, les modules time et ion ont été le support de cette interaction, utilisée pour naviguer entre les diverses planètes, grâce aux flèches du keyboard, numérotées de 0 à 3. En effet, grâce au getkey, disponible sur omega, qui est la capacité de la calculatrice à détecter si une touche est pressée, le déplacement devient envisageable.

Après plusieurs essais désastreux pour cette tâche plus complexe, nous avons chercher de l’aide auprès d’une source externe ; un grand mage.

Nous avons alors pu avoir accès à un fragment d’un de ses sortilèges que nous avons dû comprendre de nous même pour la suite de notre programme.

On définit tout d’abord dans une liste toutes les caractéristiques des planètes étudiées :

systeme = [ ("Soleil",'centre du sytème solaire','dis soleil: 0','masse: 1,989 × 10^30 kg','rayon: 696340 km', 'satellites connus: 0'),
           ("Venus",'periode de revo: 225 jours','dis soleil: 104 millions km','masse: 4,867 × 10^24 kg','rayon: 6051.8 km', 'satellites connus: 0'),
           #etc pour toutes les planètes
           ]
 
coord = [(160,111,16), (185,95,8)#etc...]
couleur1 = [[255,255,0], [190,183,150]#etc...]
couleur2 = [[235,128,0], [121,104,83]#etc...]

Ensuite on crée une fonction qui permet de tracer un rond blanc à la place de l’astre choisi lorsque degrade n’est pas égal à 1 (égal à un de base), sinon les astres restent tel quel.

def solar_systeme_dessine(n, degrade=1):
 # Affiche un corps du sytème solaire, numéro du corps dans systeme[], degradé
 p = 2 + 9 * (n != 0)
 if degrade == 1:
   cercle_grade(coord[n][0], coord[n][1], coord[n][2], couleur1[n], p, couleur2[n])
 else:
   cercle_grade(coord[n][0], coord[n][1], coord[n][2], [255,255,255], p, [255,255,255])

Avec l’ajout d’un code pour définir les touches et leur mouvement, ainsi qu’un autre pour afficher le texte voulu, on peut désormais naviguer entre les différents astres et voir leurs caractéristiques !

Conclusion

Pour pouvoir profiter du système solaire, il vous faudra donc télécharger le code via le lien en bas de page, et manipuler les flèches pour vous déportez sur les diverses planètes. Pour afficher les informations liées à chaque globe, vous manipulerez les flèches du haut et du bas. 
Bon exode planétaire !

La prochaine fois que quelqu’un se plaint que vous avez fait une erreur, dites-lui que c’est peut-être une bonne chose. Parce que sans imperfections, ni toi ni moi n’existerions.
Stephen Hawking

Télécharger et tester

Serveur Workshop de NumWorks tiplanet.org nsi.xyz 
RemarquesPermet un téléchargement rapide sur la calculatriceTéléchargement .pyTéléchargement .zip
Liens hypertexteslienNumWorks > Physique > Lien