Matricule : 20285

LABORATOIRE 4

QUESTION 1

# -*- coding: utf-8 -*-[]

"""

Created on Fri Oct 6 17:05:29 2023

@author: HP

"""

9 import numpy as np

11 x,y=(0,0)

13 v0=12

14 g=9.8

16 t=np.arange(0,(2*v0/g)*np.sin(np.pi/3),0.01)

17 print(t)

19 #on calcule les positions de x(t) et y(t)

20 x=v0*np.cos(np.pi/3)*t

21 print(x)

22 y=v0*np.sin(np.pi/3)*t - (g/2)*t**2

23 print(y)

25 with open('trajectoire.txy',mode='w') as fichier:

26 fichier.write(f"# paramètres : v0=12 m/s, tétha= 60 degrés\n")

27 fichier.write("# t (s) x (m) y(m)\n")

28 for temps, position_x, position_y in zip(t, x, y):

29 ligne_format = "{:10.2f} {:10.4f}

Réponse 1

i)Ici pour coder l’écriture des résultats dans un fichier, j’ai intégré la fonction with open…as fichier(ligne
25). Cette fonction contient 2 variables : les noms du fichier et du mode. Puis de la ligne 26 à 27 j’ai
utilisé la fonction fichier.write :

Dans un premier temps pour enregistrer les paramètres. La variable f ‘’# donne la possibilité d’afficher
les paramètres avec un nombre de chiffre specifié après le point.(L26)

Dans un second temps pour enregistre les valeurs t, x, et y en fonction de leurs unités(L27). Dans
chacune de ses parties j’ai ajouté \n pour faire un changement de ligne( afin de retourner à la ligne à
chaque fois qu’une ligne se termine).

ii)Pour le formatage, j’ai utilisé la fonction for…in zip pour créer une boucle par rapport au temps et
aux positions de x et y (L28).

A la ligne 29 on définit ligne format tel que l’on sache comment s’écrira chaque donnée. Chaque valeur
de temps doit être donner avec 2 chiffres après la virgule « {:10.2f} », et pour x,y 4 chiffres après la
virgule {:10.4f}. Le saut de ligne est toujours spécifié avec \n et sur chaque ligne on doit avoir le temps,
la position de x et la position de y (.format(temps, position_x, position_y)ligne 30).

Enfin on inclut ligne format dans le fichier avec la fonction fichier.write(ligne 31).
QUESTION 2

# -*- coding: utf-8 -*-

"""

Created on Sat Oct 14 23:15:23 2023

@author: HP

"""

8 import numpy as np

9 import matplotlib.pyplot as plt

12 with open('trajectoire.txy','r') as fichier:

13 t_liste=[]

14 x_liste=[]

15 y_liste=[]

16 #on parcourt le fichier ligne par ligne

17 for ligne in fichier:

18 #on ne considère pas les lignes ayant des # en début de ligne

19 if not ligne.startswith("#"):

20 valeurs= ligne.split()

21 t, x, y=map(float, valeurs)

23 #on ajoute les valeurs aux listes qui conviennent

24 t_liste.append(t)

25 x_liste.append(x)

26 y_liste.append(y)

28 #on transforme les listes en tableaux numpy

29 t=np.array(t_liste)

30 x=np.array(x_liste)

31 y=np.array(y_liste)

33 plt.xlabel('x')

34 plt.ylabel('y')

35 plt.title('parabole')

36 plt.grid()

37 plt.axis('equal')

38 for i in range(0,len(t)):

39 plt.plot(x[::10], y[::10], marker='D', color='olive')

41 plt.plot(x,y,color='olive', label="y en fonction de x")

42 plt.show()
Rapport :

i)En premier lieu nous avons codé la lecture des données et leur stockage dans les tableaux.

Pour la lecture des données (ligne 8-17), nous avons utilisé la fonction with open…as fichier pour
ouvrir le fichier, puis nous avons stockés les listes des variables x,y et t dans des crochets. Par la suite
nous commandons la lecture du fichier ligne par ligne avec la fonction for ligne in fichier. Puis nous
posons la condition que s’il n y a pas de ligne avec #, les valeurs doivent être découpées selon la
fonction map(float,valeurs) qui convertie les valeurs de x,y et t en nombres flottants (ligne 18-21).
Ensuite chaque valeur est ajoutée à sa liste correspondante grâce à la fonction liste.append()
(affichera chacune des listes) (ligne 23-26). Enfin nous convertissons chaque liste en tableau numpy
avec la fonction np.array(ligne 28-31).

ii)Pour afficher les points d’intervalles, nous créons une boucle qui itère de 0 à la longueur de t avec
la fonction for i in range(0 ,lent(t)) (ligne 38). Puis à la ligne 39 nous utilisons seulement chaque 10ème
éléments des tableaux x et y. De plus les points seront en losange grace à « marker=’D’ » avec la
couleur olive comme couleur de la courbes et des points.

QUESTION 3
1 import numpy as np

2 import matplotlib.pyplot as plt

4 fig1=plt.figure(1)

5 axe1=fig1.add_subplot(111)

6 fig2=plt.figure(2)

7 axe2=fig2.add_subplot(111)

9 g=9.8

11 def trajectoire(tétha,npt=500,v0=12):

12 tf=((2*v0/g)*np.sin(np.radians(tétha)))

13 t,dt=np.linspace(0,tf,npt,retstep=True)

14 x=v0*np.cos(np.radians(tétha))*t

15 y=v0*np.sin(np.radians(tétha))-(g/2)*t**2

16 return x,y,t,tf

18 tétha_tab=np.arange(25,85,5)

19 for tétha in tétha_tab:

20 x,y,t,tf=trajectoire(tétha,500,12)

21 axe1.plot(x,y,label=f'{tétha}°')

22 axe2.plot(t/tf, np.sqrt(x**2+y**2),label=f'{tétha}°')

24 p=np.sqrt(x**2+y**2)

25 z=t/tf

27 dp=np.zeros_like(p)

28 dz=z[1]-z[0]

29 dp[0]=(p[1]-p[0])/dz

30 for i in range(1,len(p)-1):

31 dp[i]=(p[i+1]-p[i-1])/(2*dz)

32 dp[-1]=(p[-1]-p[-2])/dz

34 temps_vol=t[-1]
35 portée=max(x)

36 hauteur_max=max(y)

37 distance_croissante=np.all(dp>=0)

39 print(f"angle:{tétha}°")

40 print(f"temps de vol:{temps_vol} secondes")

41 print(f"portée:{portée} mètres")

42 print(f"hauteur maximale:{hauteur_max} mètres")

43 print(f"distance strictement croissante:{distance_croissante}")

45 axe1.legend(loc='best')

46 axe1.set_xlabel('x(m)')

47 axe1.set_ylabel('y(m)')

48 axe1.set_title('trajectoires d un projectile selon différents angles')

49 fig1.savefig("trajectoires du projectile")

51 axe2.legend(loc='best')
52 axe2.set_xlabel('temps normalisé en (s)')

53 axe2.set_ylabel('distance en (m)')

54 axe2.set_title('distance d un projectile par rapport à son point de départ)

55 fig2.savefig("distance du projectile")

Rapport :

i)Pour les affichages dans deux figures(lignes 4-7), nous avons défini les figures 1 et 2 comme étant les
fonctions plt.figure. De plus nous avons aussi défini les axes 1 et 2 avec fig.add_subplot(111) en
ajoutant un sous graphique.

ii)Pour déterminer la position du maximum des courbes, nous avons utilisé la portée et la hauteur
maximale. De ce fait nous avons défini la portée comme le maximum de x et la hauteur maximale
comme le maximun selon y.
COMMENTAIRE DES FIGURES :

Ici nous constatons que les courbes qui représentent la distance du projectile par rapport à son point
de départ sont les inverses des courbes représentant les trajectoires du projectile selon divers angles.