POSITIONS SUCCESSIVES D'UN SYSTEME MODELISE PAR UN POINT

📇 Plan

Avant-propos

1. Introduction
1.1. Programme
1.2. Définitions
1.3. Eléments de base pour une représentation un graphique

2. Positions successives d’un système modélisé par un point lors d'une évolution unidimensionnelle
2.1. Valeurs des positions fournies
2.2. Valeurs des positions fournies sous forme de "listes"
2.3. Valeurs des positions calculées
2.4. Valeurs des positions calculées et placées dans des "listes"
2.5. Valeurs des positions définies en fonction de la longeur du parcours
2.6. Valeurs des positions définies en fonction de la longeur du parcours et placées dans des "listes"

3. Positions successives d’un système modélisé par un point lors d'une évolution bidimensionnelle
3.1. Trajectoire circulaire
3.1.1. Préliminaire optionel
3.1.2. Valeurs des positions fournies
3.1.3. Valeurs des positions calculées
3.2. Trajectoire curviligne (cas de la parabole)

Licence

Avant propos

💡 Présentation

Le but de ce document est de fournir quelques éléments pour aider à contruire des supports de cours adaptés aux parties du programme faisant référence aux capacités numériques. Vous pouvez l'utiliser tel quel, ou vous en inspirer pour créer vos propres supports de cours, exercices, devoirs (que vous pourrez ensuite partager sur ce site).

📝 Collaboration

Vous pouvez participer à ce document ici.

🏷️ Licence

Ce document peut-être partagé et adapté. Mais toute version du document doit conserver la même licence, y faire clairement référence, préciser les éventuelles modifications apportées et créditer clairement le ou les auteur(s). Utilisation commerciale non aurorisée. Plus d'information en fin de document.

1. Introduction

1.1. Programme

📓 Extraits du programme :

Description du mouvement d’un système par celui d’un point
Capacité numérique : représenter les positions successives d’un système modélisé par un point lors d’une évolution unidimensionnelle ou bidimensionnelle à l’aide d’un langage de programmation.

🐍 Le langage de programmation conseillé est le langage Python.

1.2. Définitions

✔️ Système

Un système est un corps ou un ensemble de corps dont on étudie le mouvement

✔️ Système modélisé par un point

Généralement, pour simplifier l'étude d'un mouvement, on choisit d'étudier le mouvement d'un seul point (appelé point mobile) du système. Il est souvent plus simple de choisir comme point mobile le centre d'inertie du système.

✔️ Trajectoire

Dans un référentiel donné, la trajectoire d'un point est l'ensemble des positions successives occupées par le point mobile au cours du temps.

1.3. Eléments de base pour une représentation un graphique

🌱 La bibliothèque matplotlib

In [13]:
# On importe les bibliothèques et les modules nécessaires
# La bibliothèque 'matplotlib' est une bibliothèque qui permet de tracer et visualiser des données sous formes de graphiques
# Voir : https://matplotlib.org/tutorials/introductory/usage.html

import matplotlib.pyplot as plt

plt.title('Positions successives d\'un système')  # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, 1, -1, 1])                           # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

2. Positions successives d’un système modélisé par un point lors d'une évolution unidimensionnelle

Soit un système assimilable à un point P qui se déplace sur un plan horizontal à une vitesse constante V0, avec T l'intervalle de temps entre deux positions successives.

2.1. Valeurs des positions fournies

In [2]:
# On reprend le code précédent et on place 5 points un par un
# après avoir calculé "à la main" les différentes positions
# avec de l'intervalle de temps choisi (T = 100 ms soit 0.1 s)
# et la vitesse V0 = 2 m.s-1
# P1 en X1 = 0
# P2 en X2 = X1 + V0*T = 0 + 2*0.1 = 0.2
# P3 en X3 = X2 + V0*T = 0.2 + 0.2 = 0.4
# ...

import matplotlib.pyplot as plt

# Valeurs en abscisse
X1 = 0
X2 = 0.2
X3 = 0.4
X4 = 0.6
X5 = 0.8

# Valeurs en ordonnée (on place le plan sur l'origine)
Y1 = Y2 = Y3 = Y4 = Y5 = 0

# On place le premier point
# marker='o' pour un rond, voir https://matplotlib.org/api/markers_api.html#module-matplotlib.markers
# color='r' pour du rouge, voir https://matplotlib.org/tutorials/colors/colors.html#sphx-glr-tutorials-colors-colors-py
plt.plot(X1, Y1, marker='o', color='r')

# Puis les suivants
plt.plot(X2, Y2, marker='o', color='r')
plt.plot(X3, Y3, marker='o', color='r')
plt.plot(X4, Y4, marker='o', color='r')
plt.plot(X5, Y5, marker='o', color='r')

plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, 1, -1, 1])                           # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

2.2. Valeurs des positions fournies sous forme de "listes"

🌱 Les listes

In [3]:
# Même code que précédemment mais en écrivant les points sour forme de 'listes'
# Le code est ainsi plus court et plus souple à manipuler

import matplotlib.pyplot as plt

# On définit les valeurs avec des listes
# Voir : https://docs.python.org/fr/3/tutorial/introduction.html#lists

# Valeurs en abscisse
X = [0, 0.2, 0.4, 0.6, 0.8]

# Valeurs en ordonnée
Y = [0, 0, 0, 0, 0]

# On trace les points
# IMPORTANT
# Précédement, nous avons placé plusieurs points sur un même graphique indépendamment les uns des autres. 
# Ainsi ils ne sont pas relié entre eux. Si on fait la même chose avec des listes, le module 'plot'
# va relier les points entre eux. Pour que les points ne soient pas reliés, il faut utiliser
# 'scatter' à la place de 'plot'.
plt.scatter(X, Y, marker='o', color='r')

plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, 1, -1, 1])                           # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

2.3. Valeurs des positions calculées

🌱 La boucle for

In [4]:
# On calcule les 5 premiers points un par un à l'aide d'une boucle 'for'
# Voir : https://wiki.python.org/moin/ForLoop
# On sait que l'espace entre deux points est de 0.2 (V0*T)

import matplotlib.pyplot as plt

# On définit les constantes
V0 = 2   # vitesse en m.s-1
T = 0.1  # temps entre deux positions successives en s

# n prend les valeurs 0, 1, 2, 3 ,4
# La première valeur de 'range' est la valeur de départ, la deuxième celle de
# fin et la troisième le pas.
# Remarque 1 : par définition, la valeur de fin est exclue - on va donc jusqu'à 5
# pour afficher 0.8
# Remarque 2 : 'range' ne manipule que des entiers
for n in range(0, 5, 1):
    X = n*V0*T
    Y = 0
    plt.plot(X, Y, marker='o', color='r')

plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, 1, -1, 1])                           # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

2.4. Valeurs des positions calculées et placées dans des "listes"

🌱 La bibliothèque numpy et les fonctions arange() et scatter

In [5]:
# Cette version du code permet de générer automatiquement les points en fonction des constantes
# Il suffit alors de modifier les valeurs des constantes pour changer les points
# La bibliothèque 'numpy' permet de manipuler des fonctions mathématiques comme 'arange'
# Voir : https://docs.scipy.org/doc/numpy/user/quickstart.html

import matplotlib.pyplot as plt
import numpy as np

# On définit les constantes
V0 = 2   # vitesse en m.s-1
T = 0.1  # intervalle de temps en s

# Valeurs en abscisse
# On utilise la fonction 'arange' de numpy pour créer une liste de valeurs
# Voir : https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.arange.html
# La première valeur est la valeur de départ, la deuxième celle de fin et la troisième 
# le pas.
# Remarque 1 : par définition, la valeur de fin est exclue - on va donc jusqu'à 1 pour
# afficher 0.8
# Remarque 2 : contrairement à 'range', 'arange' accepte des réels
X = np.arange(0, 1, V0*T)

# Valeurs en ordonnée
# On utilise la fonction 'len' de Python pour créer une liste remplie '0' de même longueur
# que la liste X (len(X))
# Voir : https://docs.python.org/3/library/functions.html?highlight=len#len
Y = [0]*len(X)

# On trace les points
plt.scatter(X, Y, marker='o', color='r')

plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, 1, -1, 1])                           # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

2.5. Valeurs des positions définies en fonction de la longeur du parcours

🌱 La boucle while et la fonction floor()

In [6]:
# On ajoute un paramètre : la longeur du parcours L 
# On calcule alors les points jusqu'à ce que la distance parcourue soit inférieure ou égale à L
# Pour cela on utilise la boucle 'while'
# Voir : https://wiki.python.org/moin/WhileLoop

import matplotlib.pyplot as plt
import numpy as np

# On définit les constantes
L = 4    # longueur du pourcours en m 
V0 = 2   # vitesse en m.s-1
T = 0.1  # intervalle de temps en s

# On calcule le nombre de distances parcourues pendant un l'intervalle de temps T dans la longueur
# du parcours L. La fonction 'floor' retourne l'entier le plus gand. Par exemple, 'floor(3,4)' donne 3.
# On obtient alors le nombre de positions moins une (problème des intervalles et des poteaux).
# Mais, en fixant le début de l'incrémentation de la boucle 'while' à 0, on ajoute de point manquant.
# Ainsi, quelques soient les valeurs choisies, il n'y a pas de position au-dela de L.
# Voir : https://docs.scipy.org/doc/numpy-1.15.1/reference/generated/numpy.floor.html
nb_inter = np.floor(L / (V0*T))

a = 0
while a <= nb_inter:
    plt.plot(a*V0*T, 0, marker='o', color='r')
    a += 1    # on ajoute 1 à la variable a (a = a + 1)
    
plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, L+1, -1, 1])                         # définition des axes [xmin, xmax, ymin, ymax]
                                                  # on ajoute 1 à L pour visualiser clairement le dernier point
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

2.6. Valeurs des positions définies en fonction de la longeur du parcours et placées dans des "listes"

🌱 La méthode append()

In [7]:
# Plutot que de tracer directement les points depuis la boucle, on les place d'abord
# dans des listes puis on les trace ensuite. Cela peut paraitre inutile ici, et 
# c'est vrai, mais cette étape sera très pratique plus tard lorsqu'il sera necessaire
# de manipuler les valeurs. Comme, par exemple, lors de la construction de vecteurs
# vitesse.

import matplotlib.pyplot as plt
import numpy as np

# On définit les constantes
L = 4    # longueur du pourcours en m 
V0 = 2   # vitesse en m.s-1
T = 0.1  # intervalle de temps en s

nb_inter = np.floor(L / (V0*T))

X = []    # on crée une liste vide

a = 0
while a <= nb_inter:
    X.append(a*V0*T)    # 'append()' ajoute une valeur à la fin de la liste X
    a += 1

Y = [0]*len(X)    # voir 2.6

# On trace les points
plt.scatter(X, Y, marker='o', color='r')

plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([0, L+1, -1, 1])                         # définition des axes [xmin, xmax, ymin, ymax]
                                                  # on ajoute 1 à L pour visualiser clairement le dernier point
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

3. Positions successives d’un système modélisé par un point lors d'une évolution bidimensionnelle

3.1. Trajectoire circulaire

Soit un système assimilable à un point P qui se deplace le long d'un cercle de rayon R à une vitesse constante de tpm tours par minute, avec T l'intervalle de temps entre deux positions successives.

3.1.1. Préliminaire optionel

🌱 La fontion linspace()

In [8]:
# Le code ci-dessous permet de tracer un cercle de rayon `R` point par point et de choisir le nombre de points.

import matplotlib.pyplot as plt
import numpy as np    # nécessaire pour 'linspace', 'pi', 'cos' et 'sin'

R = 4             # rayon en m
nb_points = 12    # nombre de points

# On crée une liste de valeurs d'angles en prenant 'nb_point' entre 0 et 2*pi grâce à la fonction 'linspace'.
# Voir : https://docs.scipy.org/doc/numpy/reference/generated/numpy.linspace.html
# La première valeur est la valeur de départ, la deuxième celle de fin et la troisième le nombre de valeurs.

angles = np.linspace(0, 2*np.pi, nb_points, endpoint=False)   # 'endpoint=False' on ne tient pas compte de la 
                                                              # dernière valeur pour ne pas tracer deux fois l'origine
# On place le centre du cercle
plt.scatter(0, 0, marker='o', color='k')

# On trace les points
plt.scatter(R*np.cos(angles), R*np.sin(angles))

plt.axis('equal')                    # même échelle pour les deux axes
plt.title('Points selon un cercle')  # titre du graphique
plt.xlabel('X (en m)')               # légende axe X
plt.ylabel('Y (en m)')               # légende axe Y
plt.axis([-R-1, R+1, -R-1, R+1])     # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                       # afficher une grille
plt.show()                           # afficher le graphique

3.1.2. Valeurs des positions fournies

In [9]:
import matplotlib.pyplot as plt

R = 4     # rayon en m
tpm = 10  # tours par minute
T = 0.5   # temps entre deux positions successives en s

# On calcule "à la main" les cinq premières positions.
# Les valeurs choisies permettent de travailler avec les 
# angles 0, 30, 60, 90... et les valeurs de leurs cos et 
# sin (rappels de mathématiques).
# Angle balayé en un temps T : alpha = (360 * tpm * T) / 60 = 30 degres
# Ainsi X1 = R*cos(0) = 4          et Y1 = R*sin(0) = 0
# Puis  X2 = R*cos(alpha) = 3.46   et Y2 = R*sin(alpha) = 2
# Et    X3 = R*cos(2*alpha) = 2    et Y3 = R*sin(2*alpha) = 3.46
# ...

# Valeurs en abscisse
X = [4, 3.46, 2, 0, -2]

# Valeurs en ordonnée
Y = [0, 2, 3.46, 4, 3.47]

# On place le centre du cercle
plt.scatter(0, 0, marker='o', color='k')

# On trace les points
plt.scatter(X, Y, marker='o', color='r')

plt.axis('equal')                                 # même échelle pour les deux axes
plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([-8, 8, -8, 8])                          # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

3.1.3. Valeurs des positions calculées

In [10]:
import matplotlib.pyplot as plt
import numpy as np

R = 4          # rayon en m
tpm = 10       # tours par minute
T = 0.1        # temps entre deux positions successives en s
nb_pos = 50    # nombre de positions

# Angle balayé en un temps T
alpha = (2*np.pi * tpm * T) / 60

# On crée des listes à l'aide d'une boucle 'for'
X = []    # initialisation de la liste X
Y = []    # initialisation de la liste Y
for n in range(0, nb_pos, 1):
    X.append(R*np.cos(n*alpha))
    Y.append(R*np.sin(n*alpha))

# On trace les points
plt.scatter(X, Y, marker='o', color='r')  

# On place le centre du cercle
plt.scatter(0, 0, marker='o', color='k')

plt.axis('equal')                                 # même échelle pour les deux axes
plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.axis([-8, 8, -8, 8])                          # définition des axes [xmin, xmax, ymin, ymax]
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique

3.2. Trajectoire curviligne (cas de la parabole)

Ouverture sur les programmes de Première et de Terminale avec une trajectoire parabolique.

In [11]:
# Pour modéliser les lois de Newtons il suffit alors d'adapter les valeurs de X et de Y

import matplotlib.pyplot as plt
import numpy as np

nb_points = 20    # nombre de points

# On crée les listes
X = np.linspace(-1, 1, nb_points)
Y = X**2

# On trace les points
plt.scatter(X, Y, marker='o', color='g')  

plt.axis('equal')                                 # même échelle pour les deux axes
plt.title('Positions successives du système')     # titre du graphique
plt.xlabel('X (en m)')                            # légende axe X
plt.ylabel('Y (en m)')                            # légende axe Y
plt.grid(True)                                    # afficher une grille
plt.show()                                        # afficher le graphique