Activité_2.1_Additionner deux signaux périodiques synchrones.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <center>Représentation de la somme de deux signaux sinusoïdaux périodiques</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 sélectionnée</b> (encadrée en vert), il faut cliquer :<br>\n",
    "<ul><li>sur le bouton \"Exécuter\" situé à côté de la cellule<br><img src=\"Jupyter_Executer.bis.jpg\"></li><br>\n",
    "<li>ou sur le bouton \"Exécuter\" dans le bandeau supérieur.\n",
    "<br>\n",
    "<center><img src=\"Jupyter_Executer.jpg\"></center><br></li></ul>\n",
    "</div>\n",
    "<div class=\"alert alert-warning\">\n",
    "<b>Travail à faire : </b> Exécuter cette ligne de code en suivant les indications ci-dessus. Du texte est affecté à la variable \"a\".\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=\"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-info\" role=\"alert\">\n",
    "Sur la gauche d'une cellule contenant du code Python, il y a l'indication <b>Entrée [&#160;&#160;]</b><br>\n",
    "<ul><li><b>Entrée [&#160;&#160;]</b> signifie que la cellule n'a pas été exécutée ;</li><br>\n",
    "<li><b>Entrée [*]</b> signifie que la cellule est en cours d'exécution. Soit il faut une action de votre part (saisie d'une valeur dans un <b>Input</b>, soit il faut donc patienter quelques secondes pour que tout le code s'exécute ;</li><br>\n",
    "<li><b>Entrée [1]</b> signifie que la cellule a été exécutée au rang 1.</li></ul><br>\n",
    "<br>\n",
    "</div>\n",
    "<div class=\"alert alert-warning\">\n",
    "<b>Travail à faire : </b> Exécuter cette ligne de code qui permet d'afficher la valeur de la variable \"a\".\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\" role=\"alert\">\n",
    "<details>\n",
    "<summary><b>A LIRE SI VOUS ÊTES EN LIGNE (en cliquant ici ou sur la flèche à gauche)</b>: Explications pour sauvegarder vos modifications au fur et à mesure.</summary>\n",
    "<p>En cas d'inactivité prolongé (entre 5 et 10 min), le notebook Jupyter sera déconnecté.<br>\n",
    "<img src=\"Jupyter_deconnected.jpg\"><br>\n",
    "Pour éviter de perdre vos modifications de code, enregistrez régulièrement votre notebook dans votre navigateur.<br>\n",
    "<img src=\"Jupyter_save.jpg\"><br>\n",
    "Le message suivant s'affiche :\n",
    "<img src=\"Jupyter_save_2.jpg\"><br>\n",
    "En cas de déconnexion, vous devez réouvrir votre notebook puis vous pouvez charger votre sauvegarde.<br>\n",
    "<img src=\"Jupyter_open.jpg\"><br>\n",
    "Le message suivant s'affiche et vous devez cliquer sur \"OK\" :\n",
    "<img src=\"Jupyter_open_2.jpg\"><br>\n",
    "Vous devez exécuter toutes les cellules modifiées depuis le début. Pour le faire rapidement, il faut cliquer sur \"Restart & Run all\" dans le menu Kernel.<br>\n",
    "<img src=\"Jupyter_restart.jpg\"><br></p>\n",
    "Le message suivant s'affiche et vous devez cliquer sur \"Restart & Run All Cells\" :\n",
    "<img src=\"Jupyter_restart_2.jpg\"><br>\n",
    "</details>\n",
    "</div>\n",
    "\n",
    "<div class=\"alert alert-danger\" role=\"alert\">\n",
    "<center><font size=\"5\">Ne modifier que la partie du code contenant ---A COMPLETER---</font></center>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Génération et somme des coordonnées deux signaux périodiques synchrones\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> À l'aide de vos connaissance de classe de première, compléter la fonction ci-dessous pour générer les coordonnées des deux signaux sinusoïdaux.\n",
    "<br>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°1</summary>\n",
    "<p>Les paramètres de la fonction <font color=red><i>signal</i></font> sont des variables nommées A, T et phi.</p>\n",
    "</details>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°2</summary>\n",
    "<p>Une fonction sinusoïdale au cours du temps, notée s(t), d'amplitude A, de période T et de phase $\\phi$ peut être décrite par l'équation suivante :<br>\n",
    "$s(t) \\ = \\ A \\times \\ sin\\ (\\frac{2 \\ \\times \\pi}{T}\\times t\\  + \\ \\phi)$</p>\n",
    "</details>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°3</summary>\n",
    "<p>Le nombre $\\pi$ s'écrit pi.</p>\n",
    "</details>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°4</summary>\n",
    "<p>L'élément à la position i d'une liste nommée t se note t[i].</p>\n",
    "</details>\n",
    "<br>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi, sin\n",
    "\n",
    "\"\"\"\n",
    "Fonction générant les coordonnées d'un signal sinusoïdal s(t) avec une phase à l'origine\n",
    "Entrées : amplitude A (en ua), période T (en s), phase (en radian)\n",
    "Résultat : liste des coordonnées du signal\n",
    "\"\"\"\n",
    "\n",
    "def signal(A,T,phi):\n",
    "    t=[]                                     # Création d'une liste vide pour le temps en s\n",
    "    s=[]                                     # Création d'une liste vide pour l'image de la fonction sinusoïdale s(t) en ua\n",
    "    points=1000                              # 1 000 couples de coordonnées\n",
    "    for i in range(points):                  # Boucle pour compléter la liste\n",
    "        t.append(10*i*T/points)              # Ajout du temps en s commençant à t = 0 s\n",
    "        if t[-1]<3*T-T*phi/(2*pi):           # L'onde n'arrive au point M qu'après 3 périodes moins la phase\n",
    "            s.append(0)                      # Le point M est au repos\n",
    "        else:\n",
    "            s.append(---A COMPLETER---)      # Ajout de l'image de la fonction sinusoïdale s(t) avec une phase phi\n",
    "    return [t,s]                             # Renvoie une liste image de la fonction sinusoïdale s(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\" role=\"alert\">\n",
    "Exécuter le bloc ci-dessous pour vérifier que votre fonction est correcte. (Aucune compréhension du code n'est demandée)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert signal(2,10,0)[1][-1] == -0.12558103905862383 , \"Vérifier l'amplitude et/ou la période dans l'expression de la fonction sinusoïdale  \"\n",
    "assert signal(20,3.5,-pi/2)[1][-1] ==-19.960534568565432, \"Vérifier la phase dans l'expression de la fonction sinusoïdale  \"\n",
    "print(\"Bravo, votre fonction est correcte. Vous pouvez continuer.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> Après avoir compris le fonctionnement de la fonction <font color=red><i>signal</i></font>, compléter la fonction ci-dessous pour générer les coordonnées de la somme de deux signaux.\n",
    "<br>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°1</summary>\n",
    "<p>Les paramètres de la fonction sont des listes nommées signal_1 et signal_2.</p>\n",
    "</details>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°2</summary>\n",
    "<p>La fonction <font color=red><i>len</i></font> permet de connaître le nombre d'éléments présents dans la liste, c'est-à-dire sa longueur.</p>\n",
    "</details>\n",
    "<br>\n",
    "<details>\n",
    "<summary>Aide n°3</summary>\n",
    "<p>L'élément à la position i d'une liste nommée signal_1 se note signal_1[i].</p>\n",
    "</details>\n",
    "<br>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Fonction générant les coordonnées de la somme de deux signaux périodiques synchrones\n",
    "Entrées : coordonnées du premier signal, coordonnées du second signal\n",
    "Résultat : liste des coordonnées de la somme deux signaux périodiques synchrones\n",
    "\"\"\"\n",
    "def somme_signaux_synchrones(signal_1,signal_2):\n",
    "    s=[]                                    # Création d'une liste vide pour faire la somme deux signaux périodiques synchrones\n",
    "    for i in range(len(---A COMPLETER---)): # Boucle pour compléter la liste\n",
    "        s.append(---A COMPLETER---)         # Ajout de la somme de l'amplitude des signaux 1 et 2\n",
    "    return s "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\" role=\"alert\">\n",
    "Exécuter le bloc ci-dessous pour vérifier que votre fonction est correcte. (Aucune compréhension du code n'est demandée)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "assert somme_signaux_synchrones(signal(2,10,0)[1],signal(2,10,0)[1])[-1] == 2*-0.12558103905862383 , \"Vérifier votre boucle et/ou la somme\"\n",
    "assert somme_signaux_synchrones(signal(20,3.5,-pi/2)[1],signal(2,10,0)[1])[-1], \"Vérifier votre boucle et/ou la somme \"\n",
    "print(\"Bravo, votre fonction est correcte. Vous pouvez continuer.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-success\" role=\"alert\">\n",
    "Exécuter le bloc ci-dessous. (Aucune compréhension du code n'est demandée)\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def preview_1():\n",
    "    A,T=amplitude.value,periode.value\n",
    "    t,s1=signal(A,T,0)\n",
    "    with out_1:\n",
    "        out_1.clear_output()\n",
    "        plt.figure(figsize=(12,4))\n",
    "        plt.title('Signal n°1') \n",
    "        plt.plot(t,s1,color=\"blue\",linewidth=1.0,linestyle=\"-.\",\n",
    "         label=\"A1 = {:.1f} ua, T1 = {:.1f} s et phi1 = 0 rad\".format(A,T))\n",
    "        plt.xlim(0,max(t))                                    # Bornes de l'axe des abscisses\n",
    "        plt.ylim(-21,21)                                      # Bornes de l'axe des ordonnées\n",
    "        plt.xlabel('temps (en s)')                            # légende axe des abscisses\n",
    "        plt.ylabel('amplitude (en ua)')                       # légende axe des ordonnées\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "\n",
    "def preview_2():\n",
    "    A,T,phi=amplitude.value,periode.value,phase.value*pi\n",
    "    t,s1=signal(A,T,0)\n",
    "    t,s2=signal(A,T,phi)\n",
    "    with out_1:\n",
    "        out_1.clear_output()\n",
    "        plt.figure(figsize=(12,4))\n",
    "        plt.title('Signal n°1') \n",
    "        plt.plot(t,s1,color=\"blue\",linewidth=1.0,linestyle=\"-.\",\n",
    "         label=\"A1 = {:.1f} ua, T1 = {:.1f} s et phi1 = 0 rad\".format(A,T))\n",
    "        plt.xlim(0,max(t))                                    # Bornes de l'axe des abscisses\n",
    "        plt.ylim(-21,21)                                      # Bornes de l'axe des ordonnées\n",
    "        plt.xlabel('temps (en s)')                            # légende axe des abscisses\n",
    "        plt.ylabel('amplitude (en ua)')                       # légende axe des ordonnées\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "    with out_2:\n",
    "        out_2.clear_output()\n",
    "        plt.figure(figsize=(12,4))\n",
    "        plt.plot(t,s2,color=\"green\",linewidth=1.0,linestyle=\"--\",\n",
    "         label=\"A2 = {:.1f} ua, T2 = {:.1f} s et phi2 = {:.2f} rad\".format(A,T,phi))\n",
    "        plt.title('Signal n°2') \n",
    "        plt.xlim(0,max(t))                                    # Bornes de l'axe des abscisses\n",
    "        plt.ylim(-21,21)                                      # Bornes de l'axe des ordonnées\n",
    "        plt.xlabel('temps (en s)')                            # légende axe des abscisses\n",
    "        plt.ylabel('amplitude (en ua)')                       # légende axe des ordonnées\n",
    "        plt.legend()\n",
    "        plt.show()       \n",
    "\n",
    "def preview_3():\n",
    "    A,T,phi=amplitude.value,periode.value,phase.value*pi\n",
    "    t,s1=signal(A,T,0)\n",
    "    t,s2=signal(A,T,phi)\n",
    "    s3=somme_signaux_synchrones(s1,s2)\n",
    "    with out_1:\n",
    "        out_1.clear_output()\n",
    "        plt.figure(figsize=(12,4))\n",
    "        plt.title('Signal n°1') \n",
    "        plt.plot(t,s1,color=\"blue\",linewidth=1.0,linestyle=\"-.\",\n",
    "         label=\"A1 = {:.1f} ua, T1 = {:.1f} s et phi1 = 0 rad\".format(A,T))\n",
    "        plt.xlim(0,max(t))                                    # Bornes de l'axe des abscisses\n",
    "        plt.ylim(-21,21)                                      # Bornes de l'axe des ordonnées\n",
    "        plt.xlabel('temps (en s)')                            # légende axe des abscisses\n",
    "        plt.ylabel('amplitude (en ua)')                       # légende axe des ordonnées\n",
    "        plt.legend()\n",
    "        plt.show()\n",
    "    with out_2:\n",
    "        out_2.clear_output()\n",
    "        plt.figure(figsize=(12,4))\n",
    "        plt.plot(t,s2,color=\"green\",linewidth=1.0,linestyle=\"--\",\n",
    "         label=\"A2 = {:.1f} ua, T2 = {:.1f} s et phi2 = {:.2f} rad\".format(A,T,phi))\n",
    "        plt.title('Signal n°2') \n",
    "        plt.xlim(0,max(t))                                    # Bornes de l'axe des abscisses\n",
    "        plt.ylim(-21,21)                                      # Bornes de l'axe des ordonnées\n",
    "        plt.xlabel('temps (en s)')                            # légende axe des abscisses\n",
    "        plt.ylabel('amplitude (en ua)')                       # légende axe des ordonnées\n",
    "        plt.legend()\n",
    "        plt.show()       \n",
    "    with out_3:\n",
    "        out_3.clear_output()\n",
    "        plt.figure(figsize=(12,4))\n",
    "        plt.plot(t,s1,color=\"blue\",linewidth=1.0,linestyle=\"-.\",\n",
    "         label=\"signal n°1\")\n",
    "        plt.plot(t,s2,color=\"green\",linewidth=1,linestyle=\"--\",\n",
    "         label=\"signal n°2\")\n",
    "        plt.plot(t,s3,color=\"red\",linewidth=1,linestyle=\"-\",\n",
    "         label=\"somme des 2 signaux\")\n",
    "        plt.title('Somme des deux signaux périodiques synchrones') \n",
    "        plt.xlim(0,max(t))                                    # Bornes de l'axe des abscisses\n",
    "        plt.ylim(-21,21)                                      # Bornes de l'axe des ordonnées\n",
    "        plt.xlabel('temps (en s)')                            # légende axe des abscisses\n",
    "        plt.ylabel('amplitude (en ua)')                       # légende axe des ordonnées\n",
    "        plt.legend()\n",
    "        plt.show()       \n",
    "        \n",
    "def preview_clicked_1(b):\n",
    "    preview_1()\n",
    "    \n",
    "def preview_clicked_2(b):\n",
    "    preview_2()\n",
    "    \n",
    "def preview_clicked_3(b):\n",
    "    preview_3()\n",
    "    \n",
    "tab = widgets.Tab()    \n",
    "out_1 = widgets.Output(layout={'border': '1px solid black'})\n",
    "out_2 = widgets.Output(layout={'border': '1px solid black'})\n",
    "out_3 = widgets.Output(layout={'border': '1px solid black'})\n",
    "\n",
    "\n",
    "amplitude = widgets.FloatSlider(\n",
    "    value=5,\n",
    "    min=0,\n",
    "    max=10.0,\n",
    "    step=0.1,\n",
    "    #description='Amplitude du signal (en s)',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "periode = widgets.FloatSlider(\n",
    "    value=2,\n",
    "    min=0,\n",
    "    max=10.0,\n",
    "    step=0.1,\n",
    "    #description='Amplitude du signal en unité arbitraire (ua)',\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.1f',\n",
    ")\n",
    "\n",
    "\n",
    "phase = widgets.FloatSlider(\n",
    "    value=0.5,\n",
    "    min=-4,\n",
    "    max=4,\n",
    "    step=0.25,\n",
    "    #description=\"phase (multiple de pi en radian)\",\n",
    "    disabled=False,\n",
    "    continuous_update=False,\n",
    "    orientation='horizontal',\n",
    "    readout=True,\n",
    "    readout_format='.2f',\n",
    ")\n",
    "\n",
    "layout = widgets.Layout(width='auto', height='40px') #set width and height\n",
    "\n",
    "button_preview_1 = widgets.Button(\n",
    "    description='Aperçu du signal n°1',\n",
    "    disabled=False,\n",
    "    button_style='info',\n",
    "    tooltip='Cliquer pour voir',\n",
    "    icon='search',\n",
    "    layout=layout)\n",
    "\n",
    "button_preview_1.on_click(preview_clicked_1)\n",
    "             \n",
    "button_preview_2 = widgets.Button(\n",
    "    description='Aperçu du signal n°2',\n",
    "    disabled=False,\n",
    "    button_style='success',\n",
    "    tooltip='Cliquer pour voir',\n",
    "    icon='search',\n",
    "    layout=layout)\n",
    "\n",
    "button_preview_2.on_click(preview_clicked_2)\n",
    "\n",
    "button_preview_3 = widgets.Button(\n",
    "    description='Aperçu de la somme des deux signaux synchrones',\n",
    "    disabled=False,\n",
    "    button_style='danger',\n",
    "    tooltip='Cliquer pour voir',\n",
    "    icon='search',\n",
    "    layout=layout)\n",
    "\n",
    "button_preview_3.on_click(preview_clicked_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "Le programme Python va modéliser l'arrivée au point $M$ des ondes (mécaniques) issues des sources $S_{1}$ et $S_{2}$ ainsi que leur superposition.\n",
    "<center><img src=\"situation.jpg\"></center>\n",
    "</div>\n",
    "<div class=\"alert alert-success\" role=\"alert\">\n",
    "Exécuter le bloc ci-dessous. (Aucune compréhension du code n'est demandée)<br>\n",
    "</div>\n",
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> Suivez les consignes qui vont s'afficher pour générer un premier signal sinusoïdal d'amplitude 8,2 ua et de période 6,3 s (la phase est nulle), puis un second signal synchrone (même fréquence avec un déphasage constant) et de même amplitude mais avec une phase à l'origine égal à $+ \\ \\frac{3\\pi}{2}$ et enfin la somme des deux signaux.\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "widgets.VBox([\n",
    "    widgets.HTML(value = f\"<b><font color='blue'>Etape n°1 : Sélectionner les paramètres du signal sinusoïdal n°1</b>\"),\n",
    "    widgets.HBox([widgets.Label('Amplitude du signal en unité arbitraire (ua):'),amplitude]),\n",
    "    widgets.HBox([widgets.Label('Période du signal en seconde (s):'),periode]),\n",
    "    button_preview_1,\n",
    "    out_1,\n",
    "    widgets.HTML(value = f\"<b><font color='grenn'>Etape n°2 : Sélectionner la phase du signal sinusoïdal n°2 qui est synchrone au signal n°1 </b>\"),\n",
    "    widgets.HBox([widgets.Label(r'phase (\\(\\times \\  \\pi\\) en radi)'),phase]),\n",
    "    button_preview_2,\n",
    "    out_2,\n",
    "    widgets.HTML(value = f\"<b><font color='red'>Etape n°3</b>\"),\n",
    "    button_preview_3,\n",
    "    out_3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> Les signaux n°1 et n°2 sont-ils <b>parfaitement</b> en phase ou en opposition de phase ?\n",
    "<br><br>\n",
    "<details>\n",
    "<summary>Correction</summary>\n",
    "<p>Les signaux ne sont ni en phase, ni en opposition de phase. Il s'agit d'un cas intermédiaire.</p><br>\n",
    "<center><img src=\"correction_1.jpg\"></center>\n",
    "</details>\n",
    "<br>\n",
    "</div>\n",
    "<div class=\"alert alert-success\" role=\"alert\">\n",
    "Revenons sur la situation étudiée lors du TP interférences<br>\n",
    "<center><img src=\"interferences_jupyter.jpg\" width=\"296\" height=\"320\"></center><br>    \n",
    "</div>\n",
    "<div class=\"alert alert-warning\" role=\"alert\">\n",
    "<b>Travail à faire : </b> <ul>\n",
    "    <li>À l'aide des résultats votre compte-rendu de TP, indiquer si les interférences au point $M_{1}$ sont constructives ou destructives.</li>\n",
    "    <li>Indiquer le signal arrivant en premier au point $M_{1}$.</li>\n",
    "    <li>Modifier (par tatonnement) la phase à l'origine, <b>en respectant son signe</b>, du signal n°2 pour simuler l'arrivée au point $M_{1}$ des ondes issues des sources $S_{1}$ et $S_{2}$. (Cliquer directement sur le bouton de l'étape n°3 pour visualiser la simulation.)</li></ul><br>\n",
    "    \n",
    "<details>\n",
    "<summary>Correction pour le point $M_{1}$</summary>\n",
    "<ul>\n",
    "    <li>Les interférences au point $M_{1}$ sont destructives.</li>\n",
    "    <li>L'onde issue de $S_{1}$ arrive avant celle issue de $S_{2}$.</li>\n",
    "    <li>Les deux signaux doivent être en opposition de phase. La phase à l'origine pour le signal n°2 vaut $\\phi \\ = - \\ \\pi$ (car $\\delta  = -  \\frac{\\lambda}{2}$). </ul><br>\n",
    "<center><img src=\"correction_2.jpg\"></center>\n",
    "</details>\n",
    "<br>\n",
    "\n",
    "<b>Travail à faire : </b> Modifier la phase à l'origine du signal n°2 pour simuler des interférences constructives au point $M_{1}$.\n",
    "<br><br>\n",
    "<details>\n",
    "<summary>Correction</summary>\n",
    "<ul>\n",
    "    <li>L'onde issue de $S_{1}$ arrive avant celle issue de $S_{2}$.</li>\n",
    "    <li>Les deux signaux doivent être en phase. La phase à l'origine pour le signal n°2 peut prendre les valeurs $\\phi \\ = - \\ 2\\pi$  ou $\\phi \\ = - \\ 4\\pi$ </ul><br>\n",
    "</details>\n",
    "</div>"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}