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='xy',angles='xy', scale=12)
        plt.quiverkey(V,0.8,0.8,500,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='xy',angles='xy', scale=2, color='red')
        plt.quiverkey(DV,0.8,0.8,100,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='xy',angles='xy', scale=1, color='g')
        plt.quiverkey(F,0.8,0.8,50,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 des axes des abscisses et des ordonnées 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='xy',angles='xy', scale=2, color='red')
        plt.quiverkey(DV,0.8,0.8,100,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 :