Activité_TP_M1_Mouvement d'un projectile.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>TP M1 : Mouvement d'un projectile : </center>\n",
    "\n",
    "<div class=\"alert alert-info\" role=\"alert\">\n",
    "Un notebook Jupyter est composé de deux types de cellules :<br>\n",
    "<ul><li> des cellules contenant du <b>texte</b> qu'il est nécessaire <b>de lire pour suivre correctement les consignes</b> ;</li><br>\n",
    "<li>des cellules contenant du <b>code Python</b> qu'il est nécessaire <b>d'éxécuter dans l'ordre d'apparition</b>.</li></ul><br>\n",
    "<br>\n",
    "<b>Pour exécuter une cellule de code</b> (grisé), il faut cliquer sur le bouton \"Exécuter\" dans le bandeau supérieur.\n",
    "<br>\n",
    "<center><img src=\"bouton_exécuter.jpg\"></center><br></li></ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "<img src=\"catapult.jpg\" alt=\"photo\" width=\"60%\"/> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> On réalise le pointage des coorodnnées (x,y) du point M à différentes dates t d'un boulet au laboratoire. Exécuter le code n°1 ci-dessous et noter les équations horaires x(t) et y(t) de la position obtenues par la modélisation des coordonées du pointage .\n",
    "<br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "#Pointage des positions du point M à différentes dates t\n",
    "x=[0.06, 0.1098, 0.1596, 0.20939999999999998, 0.2592, 0.30999999999999994, 0.35879999999999995, 0.40859999999999996, 0.4584, 0.5082, 0.5579999999999999, 0.6077999999999999, 0.6576, 0.7074, 0.7581999999999999, 0.8069999999999999, 0.8568, 0.9066000000000001]\n",
    "y=[0.09, 0.16677999999999997, 0.21492, 0.26442, 0.30528, 0.3385, 0.36107999999999996, 0.37602, 0.38232, 0.37998, 0.369, 0.3493799999999999, 0.32111999999999996, 0.28422000000000003, 0.23868000000000025, 0.18450000000000003, 0.12167999999999993, 0.05022000000000007]\n",
    "t=[0,0.03,0.06,0.09,0.12,0.15,0.18,0.21,0.24,0.27,0.30,0.33,0.36,0.39,0.42,0.45,0.48,0.51]\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "# Equation horaire x(t)\n",
    "plt.figure(1)\n",
    "plt.plot(t,x,'+',ms=18,color='red',label='pointage') #tracé de x en fonction du temps\n",
    "plt.rcParams['figure.figsize'] = [10, 10]# taille de l'affichage du graphique\n",
    "plt.xlabel(\"t en s\")\n",
    "plt.ylabel (\"x en m\")\n",
    "plt.title(\" x en fonction de t\")\n",
    "plt.axis('equal')    # repère orthonormé\n",
    "plt.grid()\n",
    "\n",
    "# Modélisation de x(t)\n",
    "tmod=np.array(t)\n",
    "a,b=np.polyfit(t,x,1) #modélisation par une fonction polynome du 1er degré (fonction linéaire)\n",
    "xmod=a*tmod+b \n",
    "plt.plot(tmod,xmod,label='modélisation')\n",
    "plt.legend()\n",
    "print (\"modélisation :x=\",a,\"t+\",b) \n",
    "\n",
    "\n",
    "# Equation horaire y(t)\n",
    "plt.figure(2)\n",
    "plt.plot(t,y,'+',ms=18,color='red',label='pointage') #tracé de y en fonction du temps\n",
    "plt.rcParams['figure.figsize'] = [10, 10]# taille de l'affichage du graphique\n",
    "plt.xlabel(\"t en m\")\n",
    "plt.ylabel (\"y en m\")\n",
    "plt.title(\" y en fonction de t\")\n",
    "plt.axis('equal')    # repère orthonormé\n",
    "plt.grid()\n",
    "\n",
    "# Modélisation de y(t)\n",
    "tmod=np.array(t)\n",
    "a,b,c=np.polyfit(t,y,2) #modélisation par une fonction polynome du 2nd degré (parabole)\n",
    "ymod=a*tmod**2+b*tmod+c\n",
    "plt.plot(tmod,ymod,label='modélisation')\n",
    "plt.legend()\n",
    "print (\"modélisation :y=\",a,\"t²+\",b,\"t+\",c) \n",
    "\n",
    "# Equation trajectoire y(x)\n",
    "plt.figure(3)\n",
    "plt.plot(x,y,'+',ms=18,color='red',label='pointage')\n",
    "plt.rcParams['figure.figsize'] = [10, 10]# taille de l'affichage du graphique\n",
    "plt.xlabel(\"x en m\")\n",
    "plt.ylabel (\"y en m\")\n",
    "plt.title(\"trajectoire du point M : y en fonction de x\")\n",
    "plt.axis('equal')       # repère orthonormé\n",
    "plt.grid()\n",
    "\n",
    "# Modélisation de y(x)\n",
    "xmod=np.array(x)\n",
    "a,b,c=np.polyfit(x,y,2)\n",
    "ymod=a*xmod**2+b*xmod+c  #modélisation par une fonction polynome du 2nd degré (parabole)\n",
    "plt.plot(xmod,ymod,label='modélisation')\n",
    "plt.legend()\n",
    "print (\"modélisation :y=\",a,\"x²+\",b,\"x+\",c) \n",
    "\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> Exécuter le code n°2 ci-dessous qui permet de calculer les coordonnées des vecteurs vitesses et accéélrations, leurs normes et les tracer en chaque point M(t).\n",
    "<br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure(figsize=(20,20))  # taille de l'affichage du graphique\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "N=len(t) # Nombre de positions\n",
    "print(\"\\nLe pointage comporte\",N,\"positions numérotées de\",0,\"à\",N-1,\".\")\n",
    "\n",
    "# Tracé des points de la trajectoire y=f(x)\n",
    "plt.title('Trajectoire du point M(t)') # titre\n",
    "plt.xlabel('x (en m)',fontsize=20)                        # légende de l'axe des abscisses\n",
    "plt.ylabel('y (en m)',fontsize=20)                        # légende de l'axe des abscisses\n",
    "plt.axis('equal')                             # même échelle sur les axes\n",
    "ax.spines['right'].set_color('none')\n",
    "ax.spines['top'].set_color('none')\n",
    "ax.xaxis.set_ticks_position('bottom')\n",
    "ax.spines['bottom'].set_position(('data',0))\n",
    "ax.yaxis.set_ticks_position('left')\n",
    "ax.spines['left'].set_position(('data',0))\n",
    "\n",
    "# Représentation des points de coordonnées (x(t),y(t)),rouge'r',forme'+',taille 2\n",
    "plt.plot(x,y,'+',ms=18)\n",
    "\n",
    "#numérotation des points\n",
    "for i in range(len(x)):\n",
    "        df=max(max(x)-min(x),max(y)-min(y))/40\n",
    "        numero=str(i)\n",
    "        table = str.maketrans({str(j):chr(0x2080 + j) for j in range(10)})\n",
    "        indice=numero.translate(table) \n",
    "        plt.text(x[i],y[i]+df,'M'+indice,color='black', fontsize=20, horizontalalignment='center', verticalalignment='center')\n",
    "\n",
    "\n",
    "# Calculs des coordonnées et de la norme des vecteurs vitesse\n",
    "# rangées dans 3 listes vxi, vyi et vi\n",
    "vx,vy,v=[''],[''],[''] # La première valeur de chaque liste est remplie par\n",
    "                       # un espace pour la position 0 non calculable\n",
    "for i in range(1,N-1) :\n",
    "    # Calcul de la coordonnée vxi du vecteur vitesse sur l'axe x au point n°i\n",
    "    vxi=(x[i+1]-x[i])/(t[i+1]-t[i])\n",
    "    vx.append(vxi) # insère la valeur vxi en dernière position de la liste vx\n",
    "\n",
    "    # Calcul de la coordonnée vyi du vecteur vitesse sur l'axe y au point n°i\n",
    "    vyi=(y[i+1]-y[i])/(t[i+1]-t[i])\n",
    "    vy.append(vyi) # insère la valeur vyi en dernière position de la liste vy\n",
    "\n",
    "    # Calcul de la norme vi du vecteur vitesse au point n°i\n",
    "    vi=(vxi**2+vyi**2)**(1/2)\n",
    "    v.append(vi)  # insère la valeur vi en dernière position de la liste v\n",
    "\n",
    "# Option pour ne représenter qu'un vecteur vitesse tous les n points\n",
    "print(\"\\nReprésenter :\")\n",
    "n=int(input('\\n- un vecteur vitesse tous les n points, n= '))\n",
    "\n",
    "# Représentation des vecteurs vitesse tous les n points\n",
    "# Affichage des coordonnées vxi, vyi et de la norme vi\n",
    "print(\"\\nPoint n°\",\" \\t vx (en m.s-1)\", \" \\t vy (en m.s-1)\",\" \\t v (en m.s-1)\")\n",
    "for i in range(1,N-1,n) :\n",
    "    # Représente au point n°i de coordonnées (x[i],y[i])\n",
    "    # un vecteur de coordonnées (vx[i]/10,vy[i]/10)\n",
    "    plt.arrow(x[i], y[i], vx[i]/10, vy[i]/10, width=0.0012,\n",
    "    length_includes_head=True, head_length=0.0045, head_width=0.0045, color='g')\n",
    "    # Affiche les coordonnées (vxi,vyi) et la norme vi avec 2 décimales\n",
    "    print(i,\" \\t\\t\",'%+.2f'% vx[i],\" \\t\\t\",'%+.2f'% vy[i],\" \\t\\t\",'%.2f'% v[i])\n",
    "\n",
    "# Calculs des coordonnées des vecteurs variation de vitesse et accélération\n",
    "# rangées dans 5 listes delta_vxi, axi, delta_vyi, ayi et ai\n",
    "delta_vx,delta_vy=['',''],['',''] # Les 2 premières valeurs sont remplies par un\n",
    "ax,ay,a=['',''],['',''],['','']   # espace pour les positions 0 et 1 non calculables\n",
    "for i in range(2,N-2) :\n",
    "    # Calcul des coordonnées delta_vxi du vecteur variation de vitesse\n",
    "    # sur l'axe x au point n°i, et des coordoonées axi du vecteur accélération\n",
    "    delta_vxi=vx[i+1]-vx[i]\n",
    "    axi=delta_vxi/(t[i+1]-t[i])\n",
    "    ax.append(axi) # insère la valeur axi en dernière position de la liste ax\n",
    "\n",
    "    # Calcul des coordonnées delta_vyi du vecteur variation de vitesse\n",
    "    # sur l'axe y au point n°i, et des coordoonées ayi du vecteur accélération\n",
    "    delta_vyi=vy[i+1]-vy[i]\n",
    "    ayi=delta_vyi/(t[i+1]-t[i])\n",
    "    ay.append(ayi) # insère la valeur ayi en dernière position de la liste ay\n",
    "\n",
    "    # Calcul de la norme du vecteur accélération au point n°i\n",
    "    ai=(axi**2+ayi**2)**(1/2)\n",
    "    a.append(ai)  # insère la valeur ai en dernière position de la liste a\n",
    "\n",
    "# Option pour ne représenter qu'un vecteur accélération tous les p points\n",
    "p=int(input('\\n- un vecteur accélération tous les p points, p= '))\n",
    "\n",
    "# Représentation des vecteurs accélération tous les n points\n",
    "# Affichage des coordonnées axi, ayi et de la norme ai\n",
    "print(\"\\nPoint n°\",\" \\t ax (en m.s-2)\", \" \\t ay (en m.s-2)\",\" \\t a (en m.s-2)\")\n",
    "for i in range(2,N-2,p) :\n",
    "    # Représente au point n°i de coordonnées (x[i],y[i])\n",
    "    # un vecteur de coordonnées (ax[i]/50,ay[i]/50)\n",
    "    plt.arrow(x[i], y[i], ax[i]/50, ay[i]/50,  width=0.0005,\n",
    "    length_includes_head=True, head_length=0.0075, head_width=0.0025, color='b')\n",
    "    # Affiche les coordonnées (axi,ayi) et la norme ai avec 2 décimales\n",
    "    print(i,\" \\t\\t\",'%+.2f'% ax[i],\" \\t\\t\",'%+.2f'% ay[i],\" \\t\\t\",'%.2f'% a[i])\n",
    "\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}