TP16 Interférences.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PARTIE 1 Génération et somme des coordonnées deux signaux périodiques synchrones\n",
    "\n",
    "# Les paramètres de la fonction <font color=red><i>signal</i></font> sont des variables nommées A, T et phi # Aide n°2 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 :\n",
    "# s(t)=A*sin (2*pi*t/T+phi)\n",
    "# L'élément à la position i d'une liste nommée t se note t[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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",
    "from math import pi, sin\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)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exécuter le bloc ci-dessous pour vérifier que votre fonction est correcte. (Aucune compréhension du code n'est demandée)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo, votre fonction est correcte. Vous pouvez continuer.\n"
     ]
    }
   ],
   "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": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 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(signal_1)):          # 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": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exécuter le bloc ci-dessous pour vérifier que votre fonction est correcte. (Aucune compréhension du code n'est demandée)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bravo, votre fonction est correcte. Vous pouvez continuer.\n"
     ]
    }
   ],
   "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": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exécuter le bloc ci-dessous. (Aucune compréhension du code n'est demandée)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# En executant le bloc ci dessous vous allez tracer les deux signaux et leur somme (à chaque fois que l'on appuie sur la loupe)\n",
    "# Montrer le rôle de chaque paramètre sur l'obtention ou pas d'un phénomène d'interférence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "24ecfec5c8eb4222bb296bb636b821c2",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value=\"<b><font color='blue'>Etape n°1 : Sélectionner les paramètres du signal sinusoïdal …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "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": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# PARTIE 2 Interférences sonores Exercice du livre 60p482\n",
    "\n",
    "# Attention : le séparateur décimal est le point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fréquence du signal (Hz) = 1600\n",
      "amplitude du signal 1 = 5\n",
      "amplitude du signal 2 = 5\n",
      "célérité (m/s) = 336\n",
      "x = 86.25\n"
     ]
    }
   ],
   "source": [
    "# Saisie des paramètres des signaux (prendre valeurs de l'exercice 59)\n",
    "freq=float(input('fréquence du signal (Hz) = '))\n",
    "ampl1=float(input('amplitude du signal 1 = '))\n",
    "ampl2=float(input('amplitude du signal 2 = '))\n",
    "cel=float(input('célérité (m/s) = '))\n",
    "abscisse=A COMPLETER\n",
    "delta=A COMPLETER"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "déphasage =  5125.284014856491  =  815.7142857142857 * 2 pi\n"
     ]
    }
   ],
   "source": [
    "# Calcul du déphasage\n",
    "deph=2*pi*freq*delta/cel\n",
    "print(\"déphasage = \",deph,\" = \",deph/(2*pi),\"* 2 pi\")\n",
    "\n",
    "# Construction des listes\n",
    "import numpy as np\n",
    "listet=np.linspace(0,2/freq,250)\n",
    "listesign1=np.linspace(0,2/freq,250)\n",
    "listesign2=np.linspace(0,2/freq,250)\n",
    "listesuperpo=np.linspace(0,2/freq,250)\n",
    "\n",
    "for i in range(0,250) :\n",
    "    listesign1[i]=ampl1*sin(2*pi*freq*listet[i])\n",
    "    listesign2[i]=ampl2*sin(2*pi*freq*listet[i]+deph)\n",
    "    listesuperpo[i]=listesign1[i]+listesign2[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Tracé des graphiques\n",
    "plt.plot(compléter)   # Compléter pour afficher listesign1=f(listet) en bleu\n",
    "plt.plot(compléter)   # Compléter pour afficher listesign2=f(listet) en vert\n",
    "plt.plot(compléter)   # Compléter pour afficher listesuperpo=f(listet) en rouge\n",
    "plt.title(\"signal 1 en bleu, 2 en vert, somme en rouge\")\n",
    "plt.show()"
   ]
  }
 ],
 "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": 4
}