Author's posts

Des fonctions pour importer des données issues d’un pointage vidéo.

1 – Importation des données d’un fichier CSV ou TXT issu du logiciel LatisPro.

La fonction Latispro présentée ci dessous permet de récupérer les données (x,y,t) sous forme de listes à partir de données exportées au format CSV ou TXT depuis Latispro. L’appel à cette fonction se fait depuis le programme principal. Elle demande un paramètre à transmettre : le nom du fichier avec son extension (.txt ou .csv).

def Latispro(nom_de_fichier):
    #----------------------------------------------------
    #Extraction des données brutes du fichier de pointage
    #----------------------------------------------------
    f=open(nom_de_fichier,'r')
    donnees_brutes=f.readlines()
    f.close()
    #----------------------------------------------------
    #Retrait du "\n" de retour à la ligne
    #----------------------------------------------------
    for i in range(len(donnees_brutes)):
        donnees_brutes[i]=donnees_brutes[i][:-1]
    #----------------------------------------------------
    #Séparation des données
    #----------------------------------------------------
    donnees=[]
    if ";" in donnees_brutes[0]:
        for i in range(len(donnees_brutes)):
            donnees.append(donnees_brutes[i].split(";"))
    else:
        for i in range(len(donnees_brutes)):
            donnees.append(donnees_brutes[i].split("\t"))
    #----------------------------------------------------
    #Recherche de la colonne Temps
    #----------------------------------------------------
    for i in range(len(donnees[0])):
        if "Temps" in donnees[0][i]:
            index_T=i
    #----------------------------------------------------
    #Constitution de la liste des dates
    #----------------------------------------------------
    temps=[]
    for i in range(1,len(donnees_brutes)):
        temps.append(float(donnees[i][index_T].replace(',','.')))
    #----------------------------------------------------
    #recherche de la colonne Mouvement X
    #----------------------------------------------------
    for i in range(len(donnees[0])):
        if "X" in donnees[0][i]:
            index_X=i
    #----------------------------------------------------
    #Constitution de la liste des abscisses
    #----------------------------------------------------
    abscisses=[]
    for i in range(1,len(donnees_brutes)):
        abscisses.append(float(donnees[i][index_X].replace(',','.')))
    #recherche de la colonne Mouvement Y
    for i in range(len(donnees[0])):
        if "Y" in donnees[0][i]:
            index_Y=i
    #----------------------------------------------------
    #Constitution de la liste des ordonnees
    #----------------------------------------------------
    ordonnees=[]
    for i in range(1,len(donnees_brutes)):
        ordonnees.append(float((donnees[i][index_Y]).replace(',','.')))
    #----------------------------------------------------
    return abscisses, ordonnees, temps

#Le programme principal--------------------------------------------

x, y, t=Latispro('nom du fichier.csv')

 

1ère PC – Etudier le mouvement d’un système avec Python

Etudier la relation approchée entre la variation du vecteur vitesse d’un système modélisé par un point matériel entre deux instants voisins et la somme des forces appliquées sur celui-ci.

Point de vue qualitatif

Cette relation peut être approchée en  montrant la colinéarité entre le vecteur variation de vitesse entre deux instants proches et le vecteur représentant la somme des forces appliquées au système. Il est possible de travailler à partir de représentations graphiques :

Cette figure tracée à l’aide du module matplotlib.pyplot est divisée en 1 ligne et 3 colonnes. Le premier graphique est le subplot(1,3,1), le deuxième est le subplot(1,3,2) et le dernier est le subplot(1,3,3). Le programme Python permettant de tracer ces représentations est donc constitué :

    • D’un programme principal contenant :
        • Les données x, z et t sous forme de listes,
        • D’un appel à une fonction v_x, v_y, temps_v = calcul_vitesses(x,z,t) nommée “calcul_vitesses” qui prend les trois listes de données comme paramètres et renvoi trois listes : les coordonnées v_x et v_y du vecteur vitesse ainsi que la liste t contenant les dates correspondantes.
        • D’un appel à la fonction representation_graphique(x,z,v_x,v_y) qui est chargée de tracer les trois représentations ci-dessus.
    • D’une fonction “calcul_vitesses” développée dans le cadre de l’étude des mouvements en classe de seconde,
    • D’une fonction “représentation_graphique” mettant en forme les trois représentations graphiques souhaitées.
import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def calcul_vitesses(abscisses,ordonnees,temps):
    v_x=[]
    v_y=[]
    for n in range(len(abscisses)-1):
        v_x.append((abscisses[n+1]-abscisses[n])/(temps[n+1]-temps[n]))
        v_y.append((ordonnees[n+1]-ordonnees[n])/(temps[n+1]-temps[n]))
    temps=temps[:-1]
    return v_x,v_y,temps

def representation_graphique(abscisses,ordonnees,v_x,v_y):
    plt.figure(figsize=(10,3))
    plt.subplots_adjust(left=0.06, bottom=0.16, right=0.99, top=0.92,
                wspace=0.2, hspace=None)
    #------------------------------
    plt.subplot(1,3,1)
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Vecteur vitesse instantannée')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')
    plt.xlim(0.8*min(abscisses),1.2*max(abscisses))
    for i in range(0,len(v_x),1):
        V=plt.quiver(abscisses[i], ordonnees[i] ,v_x[i] , v_y[i],
         scale_units='x', scale=12)
        plt.quiverkey(V,0.8,0.8,10,label='v')
    #------------------------------
    plt.subplot(1,3,2)
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Variation du vecteur vitesse')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')
    plt.xlim(0.8*min(abscisses),1.2*max(abscisses))
    for i in range(1,len(v_x),1):
        DV=plt.quiver(abscisses[i],ordonnees[i],v_x[i]-v_x[i-1],v_y[i]-v_y[i-1],
        scale_units='x', scale=2, color='red')
        plt.quiverkey(DV,0.8,0.8,2,label='V(n)-V(n-1)', labelcolor='red')
    #-------------------------------
    plt.subplot(1,3,3)
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Somme des forces extérieures')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')
    plt.xlim(0.8*min(abscisses),1.2*max(abscisses))
    for i in range(1,len(v_x),1):
        F=plt.quiver(abscisses[i],ordonnees[i],0,-0.06*9.8,
        scale_units='x', scale=1, color='g')
        plt.quiverkey(F,0.8,0.8,1,label='F', labelcolor='g')
    #-------------------------------
    plt.show()

#Le programme principal--------------------------------------------

x=[0.00,0.50,1.00,1.50,2.00,2.50,3.00,3.50,4.00,4.50,5.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]

v_x,v_y,temps_v=calcul_vitesses(x,z,t)
representation_graphique(x,z,v_x,v_y)

Pour tracer les vecteurs, il est possible d’utiliser l’outil quiver du module matplotlib.pyplot. Dans l’exemple ci-dessous, le vecteur de coordonnées ( v_x[i] – v_x[i-1]  ,  v_y[i] – v_y[i-1] ) est tracé en chaque point de coordonnées ( abscisses[i]  ,  ordonnées[i] ) en couleur rouge est avec une échelle basée sur celle de l’axe des abscisses mais avec un facteur de réduction de 2 (scale=2).

for i in range(1,len(v_x),1):
        DV=plt.quiver(abscisses[i],ordonnees[i],v_x[i]-v_x[i-1],v_y[i]-v_y[i-1],
        scale_units='x', scale=2, color='red')
        plt.quiverkey(DV,0.8,0.8,2,label='V(n)-V(n-1)', labelcolor='red')

La dernière ligne du code ci-dessus place une légende (label) écrite en rouge située à 0.8 fois la taille du graphique en X comme en Y.

Point de vue quantitatif

La relation relation entre la variation du vecteur vitesse entre deux instants proches peut être approchée d’un point de vue quantitatif en créant un programme incluant une fonction de calcul de cette variation à partir des listes v_x, v_y et temps_v calculées précédemment : a, t =calcul_deltaV_deltat(v_x,v_y,temps_v). Cette fonction renvoi deux listes : l’une contenant les valeurs de la norme du vecteur variation de vitesse nommée a et l’autre, t, contenant les dates correspondantes.

import matplotlib.pyplot as plt
import numpy as np
from math import *

#Les fonctions------------------------------------------------------

def calcul_vitesses(abscisses,ordonnees,temps):
    v_x=[]
    v_y=[]
    for n in range(len(abscisses)-1):
        v_x.append((abscisses[n+1]-abscisses[n])/(temps[n+1]-temps[n]))
        v_y.append((ordonnees[n+1]-ordonnees[n])/(temps[n+1]-temps[n]))
    temps=temps[:-1]
    return v_x,v_y,temps

def calcul_deltaV_deltat(v_x, v_y,temps_v):
    a_x=[]
    a_y=[]
    a=[]
    for i in range(1,len(v_x)):
        a_x.append((v_x[i]-v_x[i-1])/(temps_v[i]-temps_v[i-1]))
        a_y.append((v_y[i]-v_y[i-1])/(temps_v[i]-temps_v[i-1]))
    for i in range(len(a_x)):
        a.append(sqrt(a_x[i]**2+a_y[i]**2))
    t=temps_v[1:]
    return a, t

def representation_graphique(a,t):
    t=np.array(t)
    a=np.array(a)
    moy=np.mean(a)
    plt.scatter(t,a,marker='+')
    plt.plot(t,0*t+9.8,color='red',label='F/m')
    plt.plot(t,0*t+moy,color='green', label='moyenne')
    plt.title('Delta_V/Delta_t en fonction du temps')
    plt.xlabel('temps (s)')
    plt.ylabel('en (m.s-2)')
    plt.xlim(0,1.2*max(t))
    plt.ylim(0,15)
    plt.grid()
    plt.legend()
    plt.show()

#Le programme principal--------------------------------------------

x=[0.00,0.50,1.00,1.50,2.00,2.50,3.00,3.50,4.00,4.50,5.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]

v_x,v_y,temps_v=calcul_vitesses(x,z,t)
a, t =calcul_deltaV_deltat(v_x,v_y,temps_v)
representation_graphique(a,t)

L’appel à la fonction representation_graphique(a,t) permet de mettre en place la représentation graphique avec :

    • Une conversion des listes a et t en tableaux Numpy pour faciliter le calcul de la moyenne du tableau a moy=np.mean(a)et les représentations graphiques,
    • Sachant que seul le poids agit pendant le mouvement, le rapport F/m est représenté par l’instruction plt.plot(t,0*t+9.8,color='red',label='F/m'),
    • La moyenne de la norme du vecteur variation de vitesse est représentée à la ligne plt.plot(t,0*t+moy,color='green', label='moyenne')

 

La représentation graphique obtenue est alors :

1ère PC : Les ondes mécaniques avec Python.

Représenter un signal périodique et illustrer l’influence de son amplitude sur sa représentation.

Pour illustrer l’influence de l’amplitude d’un signal périodique sur sa représentation, il est possible de tracer un réseau de courbes représentant le même signal mais dont l’amplitude varie. Pour cela, le programme principal est organisé de la façon suivante :

    • Une liste contient les valeurs des amplitudes successives de chaque courbe A=[1,2,3,4,5],
    • Une liste contient la liste des couleurs de chacune des courbes C=[(0.2,0,0),(0.4,0,0),(0.6,0,0),(0.8,0,0),(1,0,0)]. Les couleurs sont codés avec le système RVB. La proportion de chacune des couleurs est désignée par une valeur comprise entre 0 et 1.
    • La période du signal est fixée à 5 s.
    • Un tableau Numpy contenant les valeurs du temps t est créé avec 100 valeurs variant de 0 à 10 : t=np.linspace(0,10,100).
    • La boucle for s’exécute autant de fois qu’il y a de valeurs d’amplitudes dans la liste A. Elle créé un nouveau tableau Numpy nommé S en calculant S = A[i]*np.sin((2*np.pi/T)*t).  La chaîne de caractères “légende” qui s’affichera en légende sur la fenêtre graphique est crée de manière à indiquer les valeurs successives des amplitudes des différentes courbes tracées. Un appel à la fonction tracer(t,S,legende,C[i]) est réalisé avec quatre paramètres : le tableau t, le tableau S, la légende à afficher ainsi que la couleur de la courbe choisie dans la liste C. Cette fonction est chargée de tracer chacune des courbes.
import matplotlib.pyplot as plt
import numpy as np

#Les fonctions-----------------------------------------
def tracer(t,S,text,couleur):
    plt.title("S=f(t)")
    plt.xlabel("Temps en s")
    plt.ylabel("Amplitude du signal S")
    plt.grid()
    plt.plot(t, S, color=couleur, label=text)
    plt.legend()

#Le programme principal--------------------------------

A=[1,2,3,4,5]
C=[(0.2,0,0),(0.4,0,0),(0.6,0,0),(0.8,0,0),(1,0,0)]
T=5
t=np.linspace(0,10,100)

for i in range(len(A)):
    S = A[i]*np.sin((2*np.pi/T)*t)
    legende="A="+str(A[i])
    tracer(t,S,legende,C[i])

plt.show()

 

Représenter un signal périodique et illustrer l’influence de sa période sur sa représentation.

Pour montrer l’influence de la période du signal sur sa représentation, l’utilisation d’un réseau de courbe comme dans le programme précédent n’est pas la solution la plus pertinente car la représentation est peu lisible. Dans le programme proposé ci-dessous, des représentations du signal se succèdent avec une période de plus en plus grande. On obtient ainsi un effet d’animation qui montre l’influence de la période T sur la représentation du signal. Dans le programme principal :

    • L’amplitude du signal est fixée à une valeur de 3,
    • Un tableau Numpy contenant les valeurs de T est créé : T=np.linspace(1,5,40). Ces 40 valeurs sont comprises entre 1 s et 5 s.
    • Une boucle for va, pour chaque valeur de période contenue dans le tableau T :
        • Créer un tableau S contenant les valeurs de l’amplitude du signal au cours du temps,
        • Créer la chaîne de caractère utilisée comme légende sur la représentation graphique en concaténant le texte “T=” avec la valeur de la période formatée avec un chiffre avant et après le séparateur décimal,
        • Faire appel à la fonction tracer(t,S,legende) qui prend trois paramètres : le tableau t, le tableau S et la légende à afficher.

La fonction tracer(t,S,legende) commence par effacer la fenêtre graphique puis définit le titre du graphique, les noms des axes, affiche la grille, affiche la courbe correspondant aux valeurs du signal en rouge, place la légende en haut et à gauche du graphique et fait une pause de 0,2 s.

Les différentes courbes sont ainsi tracées toutes les 0,2 s ce qui donne l’effet d’animation.

import matplotlib.pyplot as plt
import numpy as np

#Les fonctions-----------------------------------------
def tracer(t,S,text):
    plt.clf()
    plt.title("S=f(t)")
    plt.xlabel("Temps en s")
    plt.ylabel("Amplitude du signal S")
    plt.grid()
    plt.plot(t, S, color='red', label=text)
    plt.legend(loc='upper right')
    plt.pause(0.2)

#Le programme principal--------------------------------

A=3
T=np.linspace(1,5,40)
t=np.linspace(0,10,500)

for i in range(len(T)):
    S = A*np.sin((2*np.pi/T[i])*t)
    legende="T={0:1.1f}s".format(T[i])
    tracer(t,S,legende)

plt.show()

Il est également possible de travailler à l’aide du module Tkinter pour créer un curseur permettant de régler la valeur de T. La représentation graphique de l’onde est modifiée dès que la position du curseur est modifiée.

from tkinter import *
import matplotlib.pyplot as plt
import numpy as np

#Les fonctions--------------------------------------------

def afficher(val):
    T=float(val)
    A=3
    t=np.linspace(0,10,500)
    S = A*np.sin((2*np.pi/T)*t)
    legende="T={0:1.1f}s".format(T)
    plt.clf()
    plt.title("S=f(t)")
    plt.xlabel("Temps en s")
    plt.ylabel("Amplitude du signal S")
    plt.grid()
    plt.plot(t, S, color='red', label=legende)
    plt.legend(loc='upper right')

#Le programme principal-----------------------------------

Interface=Tk()
plt.ion()
T=Scale(Interface, orient='horizontal', from_=0.5, to=5,
      resolution=0.1, tickinterval=1, length=350,
      label='Période T (en s)', command=afficher)
T.pack()
Interface.mainloop()

L’étude du programme principal nous montre une nouvelle manière de coder. Nous sommes ici dans une programmation davantage orientée objet. L’objet Interface est créé dans la première ligne du programme principal. Le graphique matplotlib.pyplot est paramétré en mode interactif. Un widget de type Scale (curseur) est créé. Son objet parent est l’interface. Le curseur est placé horizontalement, il est gradué de 0,5 à 5 s avec un pas de 0,1 s.  Des graduations sont séparées d’un seconde. La longueur du curseur est fixée à 350 pixels. On lui associe un texte (label). Dès que la position du curseur est changée par l’utilisateur, la fonction afficher est appelée.

Le widget scale nommé T est placé sur l’interface T.pack(). L’inspecteur d’événement est démarré : Interface.mainloop(). Il surveille toutes les actions de l’utilisateur (modification de la position du curseur, fermeture de l’interface).

Dans la fonction afficher, la valeur du curseur (val) est convertie en un nombre flottant et est associée à la valeur de la période T. Les tableaux Numpy t et S sont créés. La légende est mise en forme. Le graphique précédent est effacé et le nouveau est tracé. La légende est placée en haut et à droite de la représentation graphique. Lorsque le programme s’exécute, l’interface ainsi que la fenêtre graphique sont affichées :

Simuler la propagation d’une onde périodique.

Pour simuler le déplacement d’une onde, il est possible de commencer par fixer l’amplitude A de l’onde, sa période T ainsi que sa célérité v comme le propose le programme ci-dessous. On fait ensuite le choix de calculer 5 fois la valeur de la longueur d’onde et de stocker cette valeur dans la variable x_max qui servira à afficher 5 longueurs d’onde du signal dans la fenêtre graphique.

Un tableau Numpy est créé : t=np.linspace(0,10,100). Il est constitué de 100 valeurs du temps réparties sur l’intervalle compris entre 0 et 10 s. Un second tableau Numpy est construit : x=np.linspace(0,x_max,100*x_max). Il contient 100*x_max valeurs d’abscisse réparties sur l’intervalle compris entre 0 et x_max.

Une boucle calcule ensuite pour chaque valeur du temps la valeur de l’amplitude de l’onde notée y et fait ensuite appel à la fonction tracer(x,y,A,x_max) avec quatre paramètres. Cette fonction commence par effacer la représentation précédente puis elle définit un certain nombre d’éléments de la représentation graphique : son titre, le nom de chacun des axes ainsi que leurs limites, affiche la grille puis trace l’onde sinusoïdale en rouge. Une courte pause est effectuée. A chaque itération de la boucle, le graphique est effacer et retracer pour montrer le déplacement de l’onde.

import matplotlib.pyplot as plt
import numpy as np

#Les fonctions-----------------------------------------

def tracer(x, y, amplitude,x_max):
    plt.clf()
    plt.title("Représentation de l'onde")
    plt.xlabel("Déplacement (en m)")
    plt.xlim(0,x_max)
    plt.ylabel("Amplitude")
    plt.ylim(-2*amplitude,2*amplitude)
    plt.grid()
    plt.plot(x, y, color='red')
    plt.pause(0.01)

#Le programme principal--------------------------------

A=3
T=2
v=5
x_max=50
t=np.linspace(0,10,100)
x=np.linspace(0,x_max,100*x_max)
for i in range(len(t)):
    y = A*np.sin((2*np.pi/T)*(t[i]-x/v))
    tracer(x,y,A,x_max)
plt.show()

Pour travailler sur les notions de périodicité spatiale et temporelle, il peut être intéressant d’ajouter un point d’abscisse fixe sur la représentation graphique. Le programme ci-dessus est modifié de manière à répondre à cet objectif :

import matplotlib.pyplot as plt
import numpy as np

#Les fonctions-----------------------------------------
def tracer(x, y, amplitude, x_max, x_point, y_point):
    plt.clf()
    plt.title("Représentation de l'onde")
    plt.xlabel("Déplacement (en m)")
    plt.xlim(0,x_max)
    plt.ylabel("Amplitude")
    plt.ylim(-2*amplitude,2*amplitude)
    plt.grid()
    plt.plot(x, y, color='red')
    plt.plot(x_point,y_point,'bo')
    plt.pause(0.01)

#Le programme principal--------------------------------

A=3
T=2
v=5
x_max=50
xP=20
t=np.linspace(0,10,100)
x=np.linspace(0,x_max,100*x_max)
for i in range(len(t)):
    y = A*np.sin((2*np.pi/T)*(t[i]-x/v))
    yP = A*np.sin((2*np.pi/T)*(t[i]-xP/v))
    tracer(x,y,A,x_max,xP,yP)

plt.show()

1ère PC : Aspects énergétiques des phénomènes mécaniques avec Python.

Effectuer le bilan énergétique d’un système en mouvement.

Il est possible de représenter l’évolution des différentes formes d’énergie du système en mouvement au cours du temps à l’aide du programme ci-dessous :

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------
def graphique(Ec, Epp, Em, t):
    plt.title("Evolution des formes d'énergies du système")
    plt.xlabel('t en (s)')
    plt.ylabel('Energies en (J)')
    plt.xlim(0,1.2*max(t))
    plt.ylim=(0,1.2*max(Em))
    plt.plot(t,Ec,'r.',label='Ec')
    plt.plot(t,Epp,'b.',label='Epp')
    plt.plot(t,Em,'g.',label='Em')
    plt.legend()

def calcul_vitesses(abscisses,ordonnees,temps):
    v=[]
    for n in range(len(abscisses)-1):
        v_x=(abscisses[n+1]-abscisses[n])/(temps[n+1]-temps[n])
        v_y=(ordonnees[n+1]-ordonnees[n])/(temps[n+1]-temps[n])
        v.append((v_x**2+v_y**2)**0.5)
    temps=temps[:-1]
    return v,temps

#Le programme principal--------------------------------------------
x=[0.00,0.50,1.00,1.50,2.00,2.50,3.00,3.50,4.00,4.50,5.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]
masse = 2
g=9.8

v, temps_v = calcul_vitesses(x,z,t)

#-----------------------------------
Ec=[0.5*masse*vitesse**2 for vitesse in v]
#-----------------------------------
Epp=[]
for i in range(len(v)):
    Epp.append(masse*g*z[i])
#-----------------------------------
Em=[]
for i in range(len(v)):
    Em.append(Ec[i]+Epp[i])
#-----------------------------------
graphique(Ec, Epp, Em, temps_v)
plt.show()

Dans le programme principal :

    • Les listes contenant les coordonnées x et z du système sont saisies ainsi que la liste donnant les dates correspondant aux positions relevées du système,
    • Deux constantes sont définies :  la masse m du système et de l’intensité g de la pesanteur,
    •  Un appel à la fonction calcul_vitesses(x,z,t) est effectué. Elle renvoie une liste contenant les valeurs de la vitesse du système dans ses différentes positions (sauf la dernière) ainsi que la liste des dates raccourcie d’une valeur pour que les dates correspondent aux valeurs des vitesses et que ces deux listes aient la même longueur.
    • La ligne 34 permet de remplir une liste nommée Ec avec les valeurs de l’énergie cinétique du système.
    • Le code :
      Epp=[]
      for i in range(len(v)):
          Epp.append(masse*g*z[i])

      permet de calculer l’énergie potentielle de pesanteur du système en obtenant une liste de même longueur que pour l’énergie cinétique (len(v)).

    • La boucle suivante permet de calculer les valeurs de l’énergie mécanique du système.
    • Un appel à la fonction graphique(Ec, Epp, Em, temps_v) est ensuite réalisé. Cette fonction met en place tous les éléments du graphique que l’on souhaite obtenir : son titre, le nom des axes, les limites des axes, les trois courbes Ec=f(t), Epp=f(t) et Em=f(t) avec des couleurs différentes et une légende pour pouvoir se repérer.
    • Le graphique est enfin affiché.

1ère PC : Suivi et modélisation de l’évolution d’un système chimique avec Python.

Déterminer l’état final d’un système chimique siège d’une transformation chimique totale.

Dans cet article, la transformation chimique s’écrit :

a   A          +          b    B        →        …….

 

Au départ du programme, plusieurs demandes à l’utilisateur peuvent être réalisées :

  • le nombre stœchiométrique a,
  • la quantité de matière initiale en réactif A,
  • le nombre stœchiométrique b,
  • la quantité de matière initiale en réactif B.

Les informations saisies grâce à la commande input sont des chaines de caractères. Or, il est nécessaire de les transtyper de manière à pouvoir effectuer des calculs sur les valeurs saisies. La fonction eval estime la valeur correspondant à une chaine de caractère saisie. Ainsi, si l’utilisateur entre un entier ou un nombre en écriture scientifique ( 2.5E-3 par exemple), cette information sera transformée en un nombre.

Ces informations sont envoyées à la fonction avancement_maximal(a,n_Ai,b,n_Bi). Elle calcule et renvoie au programme principal la valeur de l’avancement maximal de la transformation chimique. Dans le programme principal, cette valeur est rangée dans la variable x_max : x_max=avancement_maximal(a,n_Ai,b,n_Bi).

Ensuite, les informations saisies, ainsi que la valeur de l’avancement maximal, sont envoyés à la fonction etat_final(a,n_Ai,b,n_Bi,x_max). Cette fonction commence par calculer les quantités n_A et n_B d’espèce A et B à l’état final de la transformation. Ensuite, trois situations sont possibles :

  • Ces deux quantités sont nulles, nous sommes alors dans les conditions stœchiométriques,
  • La quantité de l’espèce A est nulle. A est le réactif limitant et la fonction affiche la valeur de x_max formatée en notation scientifique avec deux chiffres après la virgule. Elle calcule puis affiche la quantité restante de l’espèce B avec le même formatage.
  • Si la quantité de A n’est pas nulle, c’est l’espèce B qui est le réactif limitant. La fonction affiche la valeur de x_max formatée en notation scientifique avec deux chiffres après la virgule. Elle calcule puis affiche la quantité restante de l’espèce A avec le même formatage.

Remarque 1 : la nullité des valeurs de n_A et n_B n’est pas vérifiée avec le test if n_A==0 : en raison des incertitudes sur le codage des nombres flottants. Le test consiste à vérifier laquelle des valeurs entre n_A et n_B est très proche de 0 : elif n_A<1E-10 :.

Remarque 2 : le formatage des données affichées est réalisé à l’aide de la fonction “format”. Dans la ligne print("x_max = {0:1.2E} mol.".format(x_max)), la valeur de la variable x_max est insérée à l’endroit où apparait {0:1.2E}. Dans le code {0:1.2E}:

    • La valeur 0 donne l’index de la variable à afficher parmi celles contenue dans la commande format(x_max). Ici, la variable x_max a un index égal à 0. La commande “format” peut contenir plusieurs variables qui peuvent être affichées dans une même phrase à l’écran. Si une seconde variable était présente, son index serait égal à 1.
    • La valeur 1 précise le nombre de chiffres que l’on veut inscrire avant le séparateur décimal,
    • La valeur 2 indique le nombre de chiffres que l’on veut afficher après le séparateur décimal,
    • “E” indique que l’on souhaite utiliser une notation par exposant utilisant le symbole ‘E’
#Les fonctions------------------------------------------------------

def avancement_maximal(a,n_Ai,b,n_Bi):
    x_max=min(n_Ai/a, n_Bi/b)
    return x_max

def etat_final(a,n_Ai,b,n_Bi,x_max):
    n_A=n_Ai-a*x_max
    n_B=n_Bi-b*x_max
    if (n_A<1E-10 and n_B<1E-10):
        print("Nous sommes dans les conditions stoechiométriques")
        print("x_max = {0:1.2E} mol.".format(x_max))
    elif n_A<1E-10 :
        n_A=0
        print("A est le réactif limitant.")
        print("x_max = {0:1.2E} mol.".format(x_max))
        print("A la fin de la transformation, il n'y a plus de A.")
        print("Il reste {0:1.2E} mol de B.".format(n_B))
    else :
        n_B=0
        print("B est le réactif limitant.")
        print("x_max = {0:1.2E} mol.".format(x_max))
        print("A la fin de la transformation, il n'y a plus de B.")
        print("Il reste {0:1.2E} mol de A.".format(n_A))

#Le programme principal---------------------------------------------
#Equation du type aA + bB -> ........

a=eval(input("Entrez le nombre stoechiométrique a :"))
n_Ai=eval(input("n_Ai = "))
b=eval(input("Entrez le nombre stoechiométrique b :"))
n_Bi=eval(input("n_Bi = "))

x_max=avancement_maximal(a,n_Ai,b,n_Bi)
etat_final(a,n_Ai,b,n_Bi,x_max)

Le programme est testé avec les valeurs suivantes :  a=1,  n_Ai=2 mol,  b=2,  n_Bi=3mol    affiche :

>>> 
B est le réactif limitant.
x_max = 1.50E+00 mol.
A la fin de la transformation, il n'y a plus de B.
Il reste 5.00E-01 mol de A.

Il est possible de faire le choix d’alléger le code de ce programme en n’ayant pas recours à des demandes à l’utilisateur. Le programme principal est alors nettement simplifié :

#Le programme principal---------------------------------------------
#Equation du type aA + bB -> ........
a, b = 1, 2
n_Ai, n_Bi= 1E-2, 4E-2

x_max=avancement_maximal(a,n_Ai,b,n_Bi)
etat_final(a,n_Ai,b,n_Bi,x_max)

Modélisation de l’évolution des quantités de matières d’un système chimique siège d’une transformation chimique totale.

Le module matplotlib.pyplot permet de tracer des graphiques dynamiques.  L’activation du graphique s’effectue avec la commande plt.ion(). Son arrêt en fin de programme s’effectue avec plt.ioff(). Dans le programme principal, l’utilisateur saisi les nombres stœchiométriques des réactifs ainsi que leurs quantités de matière initiales. Le programme appel ensuite la fonction courbes(a,n_Ai,b,n_Bi). Après l’exécution complète de cette fonction, le graphique dynamique est désactivé mais la fenêtre graphique reste affichée pour permettre une exploitation par l’utilisateur.

La fonction courbes(a,n_Ai,b,n_Bi) commence par quelques instructions d’initialisation de variables :

    • L’avancement x est mis à 0,
    • La quantité d’espèce A est initialisée à l’aide de la valeur transmise en paramètre de la fonction. Il en est de même pour la quantité d’espèce B,
    • Le pas de variation de l’avancement, nécessaire pour les calculs, est initialisé au centième de la petite des deux quantités de matière,
    • L’avancement maximal est calculé dans la variable x_max,
    • Cette valeur va âtre utile pour fixer la limite de l’axe des abscisses à 1.2 fois cette valeur,
    • La limite de l’axe des ordonnées est fixée à 1,2 fois la plus grande quantité de matière initiale,
    • Les noms des axes ainsi que la grille sont affichés,
    • Les lignes 17, 18 et 19 placent les premiers points de chacune des courbes ainsi que la légende dont l’affichage utilise les “label” des point placés,
    • La boucle de la ligne 20 permet au programme d’incrémenter la valeur de l’avancement x de la quantité dx, de calculer les quantités respectives de A et de B et de placer les points correspondant sur le graphique tant que les deux quantités de matière sont strictement positives. Dès que l’un des réactifs est épuisé, le tracé du graphique s’arrête.
import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def courbes(a,n_Ai,b,n_Bi):
    x=0
    n_A=n_Ai
    n_B=n_Bi
    dx=(min(n_A,n_B)/100)
    plt.ion()
    x_max=min(n_Ai/a,n_Bi/b)
    plt.xlim(0,1.2*x_max)
    plt.ylim(0,1.2*max(n_A,n_B))
    plt.xlabel('Avancement x (mol)')
    plt.ylabel('n (en mol)')
    plt.grid()
    plt.plot(x,n_A,'b.',label='n(A)')
    plt.plot(x,n_B,'r.',label='n(B)')
    plt.legend()
    while (n_A>0) and (n_B>0):
        plt.plot(x,n_A,'b.')
        plt.plot(x,n_B,'r.')
        plt.pause(0.01)
        x=x+dx
        n_A=n_Ai-a*x
        n_B=n_Bi-b*x


#Le programme principal---------------------------------------------
#Equation du type aA + bB -> ........
a, b = 1, 2
n_Ai, n_Bi= 1E-2, 4E-2


courbes(a,n_Ai,b,n_Bi)

plt.ioff()
plt.show()

Le programme peut être développé pour permettre l’affichage de l’évolution des quantités des produits de la réaction :

a   A          +          b    B        →       c    C        +         d    D

Dans le programme principal, l’utilisateur saisi :

    • Les nombres stœchiométriques a, b, c et d de l’équation,
    • Les quantités initiales n_Ai, n_Bi, n_Ci, et n_Di de réactifs et de produits,
    • Les noms des espèces chimiques A, B, C et  D.

Les quantités des deux réactifs sont affichées en bleu alors les quantités des deux produits apparaissent en rouge sur le graphique.

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def courbes(a,b,c,d,n_Ai,n_Bi,n_Ci,n_Di,A,B,C,D):
    x=0
    n_A, n_B, n_C, n_D = n_Ai, n_Bi, n_Ci, n_Di
    dx=(min(n_A,n_B)/100)
    plt.ion()
    x_max=min(n_Ai/a,n_Bi/b)
    plt.xlim(0,1.2*x_max)
    plt.ylim(0,1.2*max(n_A,n_B))
    plt.xlabel('Avancement x (mol)')
    plt.ylabel('n (en mol)')
    plt.grid()
    plt.plot(x,n_A,'b.',label=A)
    plt.plot(x,n_B,'b+',label=B)
    plt.plot(x,n_C,'r.',label=C)
    plt.plot(x,n_D,'r+',label=D)
    plt.legend()
    while (n_A>0) and (n_B>0):
        plt.plot(x,n_A,'b.')
        plt.plot(x,n_B,'b+')
        plt.plot(x,n_C,'r.')
        plt.plot(x,n_D,'r+')
        plt.pause(0.01)
        x=x+dx
        n_A=n_Ai-a*x
        n_B=n_Bi-b*x
        n_C=n_Ci+c*x
        n_D=n_Di+d*x


#Le programme principal---------------------------------------------
#Equation du type aA + bB -> cC +  dD
a, b, c, d = 1, 2, 1, 2
n_Ai, n_Bi, n_Ci, n_Di= 10, 30, 0, 0
A, B, C, D = "CH4", "O2", "CO2", "H2O"

courbes(a,b,c,d,n_Ai,n_Bi,n_Ci,n_Di,A,B,C,D)

plt.ioff()
plt.show()

2nde : Signaux et capteurs avec Python.

Représenter un nuage de points associé à la caractéristique d’un  dipôle.

Pour représenter un nuage de points, il est possible d’utiliser le module matplotlib.pyplot. Le graphique de type “scatter” permet une représentation de données en nuage de points. Une étude expérimentale permet d’avoir deux listes : l’une contenant les valeurs de la tension U aux bornes du dipôle et l’autre les valeurs de l’intensité I du courant le traversant. Il est assez simple de construire une fonction courbe(x,y)qui prendra deux listes en argument pour mettre en forme la caractéristique du dipôle.

import matplotlib.pyplot as plt

#Les fonctions---------------------------------------------

def courbe(x,y):
    plt.xlabel("I (A)")
    plt.ylabel("U (V)")
    plt.title("Caractéristique du dipôle")
    plt.scatter(x,y,marker='+')

#Le programme principal------------------------------------

U=[0,1,2,3,4,5]
I=[0,0.01,0.02,0.03,0.04,0.05]

courbe(I,U)
plt.show()

Modéliser la caractéristique du dipôle.

Pour modéliser la caractéristique, il est possible d’utiliser un autre module de Python : Numpy.  Le module sera importé avec un nom court (alias) “np”. La fonction polyfit de Numpy demande trois arguments : la liste des abscisses, la liste des ordonnées et le degré du polynôme choisi pour le modèle. Pour des raisons pratiques, il est intéressant que les listes U et I soient déclarées comme des tableaux numpy, des “numpy array”.

Pour un polynôme de degré 1, la fonction polyfit renvoie un tableau numpy contenant deux valeurs : [1.00000000e+02 1.81298661e-16] (pour l’exemple traité ici).  Les valeurs de ce tableau correspondent aux coefficients du polynôme modèle. La première valeur correspond au coefficient du terme de degré le plus élevé. Pour une droite, la première valeur correspond donc à son coefficient directeur et le second à son ordonnée à l’origine. La ligne modele=np.polyfit(I,U,1) range donc le tableau de résultat dans la variable nommée “modele” : modele = [1.00000000e+02 1.81298661e-16] . Pour accéder au coefficient directeur de la droite, il faut accéder à l’élément 0 du tableau “modele” soit modele[0]. L’accès à la valeur de l’ordonnée à l’origine s’effectue grâce à la syntaxe modele[1]. Il est alors possible d’écrire une fonction modelisation(x,y) prenant deux paramètres : le tableau contenant les valeurs des abscisses et celui contenant les valeurs des ordonnées :

def modelisation(x,y):
    modele=np.polyfit(x,y,1)
    equation=("U = "+format(modele[0],".2E")+"x I +"+format(modele[1],".2E"))
    plt.plot(x,modele[0]*x+modele[1],color='red',label=equation)
    plt.legend()

La ligne 3 de cette fonction met en forme l’équation de la droite qui sera affichée sur le graphique sous forme d’une légende. Les valeurs du coefficient directeur et de l’ordonnée à l’origine sont formatées en notation scientifique avec deux chiffres après la virgule : format(modele[0],".2E").

La ligne 4 permet de tracer une courbe prenant les valeurs de I en abscisse, calculant la valeur des ordonnées à partir du résultats de la modélisation et l’affichant en rouge sur le graphique avec son équation comme étiquette de légende.

Cette nouvelle fonction complète le programme affichant le nuage de point. Le modèle vient alors se superposer aux points de mesure :

import matplotlib.pyplot as plt
import numpy as np

#Les fonctions---------------------------------------------

def courbe(x,y):
    plt.xlabel("I (A)")
    plt.ylabel("U (V)")
    plt.title("Caractéristique du dipôle")
    plt.scatter(x,y,marker='+',s=100)

def modelisation(x,y):
    modele=np.polyfit(x,y,1)
    equation=("U = "+format(modele[0],".2E")+"x I +"+format(modele[1],".2E"))
    plt.plot(x,modele[0]*x+modele[1],color='red',label=equation)
    plt.legend()

#Le programme principal------------------------------------

U=np.array([0,1,2,3,4,5])
I=np.array([0,0.01,0.02,0.03,0.04,0.05])

courbe(I,U)
modelisation(I,U)
plt.show()

Pour modéliser la courbe, il est également possible d’utiliser le module scipy.stats qui fournit une fonction permettant de faire une régression linéaire : linregress. Cette fonction est importée en début de programme. La fonction modelisation(x,y) est donc modifiée pour s’adapter à cette fonction :

def modelisation(x,y):
    modele=linregress(x,y)
    equation=("U = "+format(modele[0],".2E")+"x I +"+format(modele[1],".2E")
    +"\n"+"rho = "+format(modele[2],".2E"))
    plt.plot(x,modele[0]*x+modele[1],color='red',label=equation)
    plt.legend()

La fonction linregress renvoi un tuple contenant cinq valeurs dont les trois premières peuvent être intéressantes :

  • Le coefficient directeur de la droite modèle,
  • Son ordonnée à l’origine,
  • Le coefficient de corrélation ρ.

La ligne 4 ajoute à l’équation de la droite la valeur du coefficient de corrélation après un retour à la ligne “\n”.

import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import linregress

#Les fonctions---------------------------------------------

def courbe(x,y):
    plt.xlabel("I (A)")
    plt.ylabel("U (V)")
    plt.title("Caractéristique du dipôle")
    plt.scatter(x,y,marker='+',s=100)

def modelisation(x,y):
    modele=linregress(x,y)
    equation=("U = "+format(modele[0],".2E")+"x I +"+format(modele[1],".2E")
    +"\n"+"rho = "+format(modele[2],".2E"))
    plt.plot(x,modele[0]*x+modele[1],color='red',label=equation)
    plt.legend()

#Le programme principal------------------------------------

U=np.array([0,1,2,3,4,5])
I=np.array([0,0.01,0.02,0.03,0.04,0.05])

courbe(I,U)
modelisation(I,U)
plt.show()

Il est également possible de développer une interface permettant aux élèves de réaliser une application permettant de modéliser la caractéristique du dipôle à l’aide d’un modèle personnel par la saisie d’un coefficient directeur et d’une ordonnée à l’origine. Il est également possible d’ajouter un bouton permettant de tracer le modèle calculé par Numpy.

Ce programme exploite la bibliothèque Tkinter. L’interface est crée à la ligne 36. Le module pyplot est réglé en mode dynamique plt.ion(). Tous les éléments de  l’interface sont créés et placés sur l’interface entre les lignes 41 et 62 :

    • 2 étiquettes : Label permettant d’identifier les deux champs d’entrée,
    • 2 champs d’entrée utilisateur : Entry,
    • 3 boutons permettant d’exécuter :
          • la fonction  modelisation(I,U) pour le bouton Modèle personnel,
          • la fonction  modelisation_automatique(I,U) pour le bouton Modélisation automatique,
          • la fonction  fermeture pour le bouton Fermer des fenêtres.

Tous les éléments de l’interface sont disposés sur une grille de 4 lignes et 2 colonnes grâce aux paramètres row et column de la méthode grid.

Après la construction de l’interface, la fonction   courbe(I,U)  est appelée pour tracer le graphique U=f(I). Pour finir, la boucle principale Interface.mainloop() est lancée (l’inspecteur d’événements qui surveille en permanence les actions de l’utilisateur sur l’interface).

from tkinter import *
import matplotlib.pyplot as plt
import numpy as np

#Les fonctions--------------------------------------------

def courbe(x,y):
    plt.clf()
    plt.xlabel("I (A)")
    plt.xlim(0,1.2*max(x))
    plt.ylabel("U (V)")
    plt.ylim(0,1.2*max(y))
    plt.title("Caractéristique du dipôle")
    plt.scatter(I,U,marker='+',s=100)

def modelisation(x,y):
    courbe(x,y)
    m=eval(a.get())
    p=eval(b.get())
    equation=("U = "+format(m,".2E")+"x I +"+format(p,".2E"))
    plt.plot(x,m*x+p,color='red',label=equation)
    plt.legend()

def modelisation_automatique(x,y):
    modele=np.polyfit(x,y,1)
    equation=("U = "+format(modele[0],".2E")+"x I +"+format(modele[1],".2E"))
    plt.plot(I,modele[0]*I+modele[1],color='green',label=equation)
    plt.legend()

def fermeture():
    plt.close()
    Interface.destroy()

#Le programme principal-----------------------------------

Interface=Tk()
plt.ion()
U=np.array([0,1,2,3,4,5])
I=np.array([0,0.01,0.02,0.03,0.04,0.05])

text_a=Label(Interface, text='Coefficient directeur :')
text_a.grid(row=0,column=0)
a=Entry(Interface, width=10)
a.grid(row=0,column=1)
a.insert(0,"0")
text_b=Label(Interface, text='Ordonnée à l\'origine :')
text_b.grid(row=1,column=0)
b=Entry(Interface, width=10)
b.grid(row=1,column=1)
b.insert(0,"0")
bouton=Button(Interface, text='Modèle personnel', width=24,
                foreground='red',
                command=lambda:modelisation(I,U))
bouton.grid(row=2,column=0)
bouton_mod_auto=Button(Interface, text='Modélisation automatique', width=24,
                        foreground='green',
                        command=lambda:modelisation_automatique(I,U))
bouton_mod_auto.grid(row=3,column=0)
bouton_fermer=Button(Interface, text='Fermer les fenêtres', width=24,
                        foreground='blue',
                        command=fermeture)
bouton_fermer.grid(row=4,column=0)

courbe(I,U)
Interface.mainloop()

 

2nde : Décrire un mouvement avec Python.

Représenter les positions successives d’un système modélisé par un point lors d’une évolution unidimensionnelle ou bidimensionnelle.

Supposons que les coordonnées d’un système au cours du temps sont connues. Elle sont contenues dans deux listes : x et z.

Tracer un graphique dans python nécessite d’importer un module : import matplotlib.pyplot as plt

Ensuite, les deux listes x et z ont saisies. Pour représenter les positions successives du système au cours du temps, il est possible de tracer un graphique de type “scatter” c’est à dire “point par point” sans que ces derniers ne soient reliés les uns aux autres. La commande plt.scatter(x,z)demande au moins deux arguments : la liste des valeurs à placer en abscisse ainsi que la liste des valeurs à placer en ordonnée.

Attention, la commande plt.show() est indispensable pour que la fenêtre graphique s’affiche lors de l’exécution du programme.

import matplotlib.pyplot as plt

x=[0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]

plt.scatter(x,z)
plt.show()

Ce programme simple permet d’obtenir la représentation suivante :

Il est intéressant d’améliorer cette représentation graphique en ajoutant un titre, le nom de la grandeur présente sur chacun des axes avec son unité et en remplaçant les points par des “plus” … Le nouveau code s’écrit :

import matplotlib.pyplot as plt

x=[0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]

plt.scatter(x,z,marker='+')
plt.title('Positions successives occupées par le système')
plt.xlabel('x en (m)')
plt.ylabel('Altitude z en (m)')
plt.show()

La représentation graphique obtenue est alors :

Ce programme peut être écrit sous forme d’une fonction réutilisable dans un programme plus complexe. La fonction tracer_des_positions() prend deux arguments lorsqu’elle est appelée depuis le programme principal (ligne 16) : la liste des abscisses et la liste des ordonnées.

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def tracer_des_positions(abscisses,ordonnees):
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Positions successives occupées par le système')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')
    
#Le programme principal--------------------------------------------

x=[0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]

tracer_des_positions(x,z)
plt.show()

Dans le cas d’un mouvement bidimensionnel, seules les listes des positions changent. La fonction tracer_des_positions() reste identique. L’exemple suivant présente un mouvement dans le champ de pesanteur terrestre :

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def tracer_des_positions(abscisses,ordonnees):
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Positions successives occupées par le système')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')

#Le programme principal--------------------------------------------

x=[0.00,0.50,1.00,1.50,2.00,2.50,3.00,3.50,4.00,4.50,5.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]

tracer_des_positions(x,z)
plt.show()

Représenter des vecteurs vitesse d’un système modélisé par un point lors d’un mouvement.

Plusieurs hypothèses de travail sont possibles. Soit les élèves disposent des valeurs de la vitesse du corps au cours de son mouvement, soit il est possible de les calculer en créant une fonction. Le travail s’effectuera sur un mouvement rectiligne. Considérons que la vitesse du corps n’est pas connue. Elle est calculée dans le programme ci-dessous grâce à la fonction calcul_vitesses(abscisses,temps) . Le mouvement étudié est à une dimension. La vitesse est calculée avec la méthode suivante : la vitesse au point n est calculée sur le déplacement du point n au point n+1.  La fonction demande deux listes en paramètres : la liste des abscisses et la liste du temps. Elle retourne à son tour deux listes au programme principal : la liste des vitesses instantanées sauf pour le dernier point pour lequel le calcul n’est pas possible (il n’y a pas de point n+1 disponible). La liste du temps retournée temps_v contient les mêmes valeurs que la liste t mais la dernière valeur a été retirée à la ligne 9. L’appel à cette fonction qui s’effectue depuis le programme principal range les deux listes renvoyées par la fonction dans les listes v et temps_v à la ligne 17.

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def calcul_vitesses(abscisses,temps):
    v=[]
    for i in range(len(abscisses)-1):
        v.append((abscisses[i+1]-abscisses[i])/(temps[i+1]-temps[i]))
    temps=temps[:-1]
    return v,temps

#Le programme principal--------------------------------------------

x=[0.00,0.01,0.04,0.09,0.16,0.25,0.36,0.49,0.64,0.81,1.00]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]

v,temps_v=calcul_vitesses(x,t)

Pour représenter les vecteurs vitesse, nous allons faire appel à la fonction quiver du module matplotlib.pyplot. Elle permet de représenter un vecteur de coordonnées (U,V) au point de coordonnées (X,Y) avec la syntaxe plt.quiver(X, Y, U, V).  Il est donc possible de créer une nouvelle fonction representation_vecteur_vitesse(abscisses,vitesses) qui prend deux listes en paramètres.  La boucle présente dans cette fonction permet de parcourir la liste des abscisses, d’extraire la vitesse de chaque point de la liste des vitesses et de représenter le vecteur de coordonnées (vitesse[i], 0) en chaque point de coordonnées (abscisses[i],0). La longueur des vecteurs est calculée à partir de l’échelle de l’axe x avec un facteur de réduction de 15.

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def calcul_vitesses(abscisses,temps):
    v=[]
    for n in range(len(abscisses)-1):
        v.append((abscisses[n+1]-abscisses[n])/(temps[n+1]-temps[n]))
    temps=temps[:-1]
    return v,temps

def representation_vecteur_vitesse(abscisses,vitesses):
    for i in range(len(vitesses)):
        plt.quiver(abscisses[i], 0 ,vitesses[i] , 0, scale_units='x', scale=15)

#Le programme principal--------------------------------------------

x=[0.00,0.01,0.04,0.09,0.16,0.25,0.36,0.49,0.64,0.81,1.00]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]

v,temps_v=calcul_vitesses(x,t)
representation_vecteur_vitesse(x,v)
plt.show()

Il peut être intéressant de représenter également les positions successives occupées par le système au cours du temps en ajoutant dans le programme précédent, la fonction tracer_des_positions() écrite dans un programme précédent. Cela nécessite simplement d’ajouter la liste des altitudes z du système mais qui seront toutes nulles dans le cas de notre mouvement à une dimension. Dans le nouveau programme, c’est la fonction représentation_vecteur_vitesse() qui appellera la fonction tracer_des_positions() après la définition des vecteurs grâce à la fonction plt.quiver().

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def Tracer_des_positions(abscisses,ordonnees):
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Positions successives occupées par le système')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')
    plt.xlim(0.8*min(abscisses),1.2*max(abscisses))

def calcul_vitesses(abscisses,temps):
    v=[]
    for n in range(len(abscisses)-1):
        v.append((abscisses[n+1]-abscisses[n])/(temps[n+1]-temps[n]))
    temps=temps[:-1]
    return v,temps

def representation_vecteur_vitesse(abscisses,ordonnees,vitesses):
    for i in range(len(vitesses)):
        plt.quiver(abscisses[i], 0 ,vitesses[i] , 0, scale_units='x', scale=15)
    Tracer_des_positions(abscisses,ordonnees)

#Le programme principal--------------------------------------------

x=[0.00,0.01,0.04,0.09,0.16,0.25,0.36,0.49,0.64,0.81,1.00]
z=[0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]

v,temps_v=calcul_vitesses(x,t)
representation_vecteur_vitesse(x,z,v)
plt.show()

Avec un mouvement à deux dimensions, le programme peut s’écrire de la manière suivante :

import matplotlib.pyplot as plt

#Les fonctions------------------------------------------------------

def Tracer_des_positions(abscisses,ordonnees):
    plt.scatter(abscisses,ordonnees,marker='+')
    plt.title('Positions successives occupées par le système')
    plt.xlabel('x en (m)')
    plt.ylabel('Altitude z en (m)')
    plt.xlim(0.8*min(abscisses),1.2*max(abscisses))

def calcul_vitesses(abscisses,ordonnees,temps):
    v_x=[]
    v_y=[]
    for n in range(len(abscisses)-1):
        print(n)
        v_x.append((abscisses[n+1]-abscisses[n])/(temps[n+1]-temps[n]))
        v_y.append((ordonnees[n+1]-ordonnees[n])/(temps[n+1]-temps[n]))
    temps=temps[:-1]
    return v_x,v_y,temps

def representation_vecteur_vitesse(abscisses,ordonnees,v_x,v_y):
    for i in range(len(v_x)):
        plt.quiver(abscisses[i], ordonnees[i] ,v_x[i] , v_y[i], scale_units='x', scale=15)
    Tracer_des_positions(abscisses,ordonnees)

#Le programme principal--------------------------------------------

x=[0.00,0.50,1.00,1.50,2.00,2.50,3.00,3.50,4.00,4.50,5.00]
z=[5.00,4.95,4.80,4.56,4.22,3.77,3.23,2.60,1.86,1.03,0.09]
t=[0.00,0.10,0.20,0.30,0.40,0.50,0.60,0.70,0.80,0.90,1.00]

v_x,v_y,temps_v=calcul_vitesses(x,z,t)
representation_vecteur_vitesse(x,z,v_x,v_y)
plt.show()

Des utilisations de Moodle en physique-chimie

“Parlons pédagogie et numérique !”  La DANE produit des webinaires  pour échanger avec un collègue qui accepte de présenter ses activités, ses projets et de répondre à différentes questions.
Au mois de juin 2018, c’est Joëlle FROIDUROT, une collègue de physique-chimie du lycée Germaine Tillion, qui a exposé ses utilisations pédagogiques de Moodle. Pour découvrir cet entretien, cliquer sur l’image ci-dessous :

Le mode Examen sur les calculatrices.

(341 ko)

A partir de la session 2018 du baccalauréat, les candidats devraient composer avec des calculatrices en mode “Examen”. Il semble nécessaire de préparer nos élèves. Voici donc un document rédigé par Philippe ROBERT qui synthétise les différentes procédures pour activer et désactiver le mode “Examen” sur différents modèles de calculatrices.