Caracteristique generateur reel_a completer.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tracé de la caractéristique courant-tension d'une source de tension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'>Importation des modules de calcul et de tracé de courbe.\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import de la bibliothèque numpy (gestion de matrices et routines mathématiques) en lui donnant le surnom np\n",
    "import numpy as np\n",
    "# import de la bibliothèque matplotlib (graphiques) en lui donnant le surnom plt\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'>Tableaux des valeurs des mesures de tension et de l'intensité du courant délivré par une pile en V et en A <hr>\n",
    "    <i>Compléter le tableau en notant vos mesures séparées par des virgules : <br>\n",
    "           - <code class = \"python\">U_V</code> tension en V.<br>\n",
    "       - <code class = \"python\">I_mA</code> intensité en mA.<br><br>\n",
    "        Compléter le ligne pour convertir l'intensité en ampère</i>\n",
    "    </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "U_V = np.array([    ,    ,   ])  # à compléter\n",
    "I_mA = np.array([ 0 ,    ,  ])   # à compléter\n",
    "\n",
    "I_A =    # à compléter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'>\n",
    "    Utilisation de la fonction <code class = \"python\">plot( abscisse , ordonnées ,    )</code> pour tracer la courbe.<br>\n",
    "<code class = \"python\">plot(...)</code> reçoit 3 arguments : <br>\n",
    "- la liste des valeurs en abscisses contenues dans un tableau numpy : <code class = \"python\">np.array([])</code><br>\n",
    "- la liste des valeurs en ordonnées contenues dans un tableau numpy.<br>\n",
    "- une chaîne de caractère qui précise le type de marquage : <code class = \"python\"></code> pour \"gros point bleu\"\n",
    "    <hr>\n",
    "    <i>Compléter la fonction <code class = \"python\">plot(  , ,\"bo\")</code> permettant de représenter la caractéristique tension-intensité U = f(I)</i>    </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(   ,   ,\"bo\")   # à compléter\n",
    "\n",
    "plt.show() # affiche la figure a l'ecran"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <div class = 'alert alert-warning'><h4>Amélioration de la présentation du graphe</h4>\n",
    " <hr>\n",
    " <i>- Donner un titre au graphique <code class = \"python\">plt.title(...)</code><br>\n",
    " - Afficher le symbole et l'unité des grandeurs représentées en abscisses et en ordonnées <code class = \"python\">plt.   label(...)</code><br></i><br>\n",
    "    <b>Remarque</b> : pour afficher une chaîne caractère, elle doit être écrite entre guillemets <code class = \"python\">\"...\"</code><br> \n",
    "    </div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Tracé de la caractéristique avec titre, axes et unités\n",
    "\n",
    "plt.plot(I_A, U_V, \"b+\")\n",
    "\n",
    "# Ecriture scientifique pour l'affichage de l'intensité\n",
    "plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))\n",
    "\n",
    "# Légende des axes et titre\n",
    "plt.xlabel(\"      \")    # à compléter\n",
    "plt.ylabel(       )     # à compléter\n",
    "\n",
    "plt.title(       )      # à compléter\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'><h3>Importation de la fonction <code class = \"python\">linregress</code> du module <code class = \"python\">scipy.stats</code></h3></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# import de la bibliothèque pour faire une régression linéaire\n",
    "\n",
    "from scipy.stats import linregress\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modélisation par une droite affine\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'>\n",
    "Calcul du coefficient directeur et de l'ordonnée à l'origine de la droite obtenue par regression linéaire (méthode qui minimise la distance entre les points et la droite)\n",
    "    <br><br>\n",
    "    la fonction <code class = \"python\">linregress(abscisses,ordonnées)</code> renvoie plusieurs variables<br>\n",
    "    - la variable <code class = \"python\">...[0]</code> est le coefficient directeur<br>\n",
    "    - la variable <code class = \"python\">...[1]</code> est l'ordonnée à l'origine.\n",
    "      <hr>\n",
    "    <i>Compléter la fonction <code class = \"python\">linregress(   )</code></i>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Regression linéaire pour la modélisation\n",
    "regression=linregress(   ,   )              # à compléter\n",
    "pente=regression[0]\n",
    "ordonnee_origine = regression[1]\n",
    "\n",
    "print (\"E_g = \",ordonnee_origine,\"V\")\n",
    "print (\"r_g = \",abs(pente), chr(937))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'><h4>Mise en forme du résultat</h4><hr>\n",
    "   <i> Changer la mise en forme des valeurs pour n'afficher que 3 chiffres significatifs</i></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pente_a = round(pente,3)\n",
    "ordonnee_origine_a = round (ordonnee_origine,2)\n",
    "\n",
    "print (\"E_g = \",ordonnee_origine_a,\"V\")\n",
    "print (\"r_g = \",abs(pente_a), chr(937))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'><h4>Tracé de la droite modélisant la relation entre la tension et l'intensité</h4>\n",
    "<br><br>\n",
    "   <i> Compléter l'équation du modèle qui permet de calculer <code class = \"python\">U_mod</code> en fonction de la variable <code class = \"python\">I_mod</code><br>\n",
    "    </i>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# On veut tracer la régression linéaire sur les points issus des données\n",
    "# valeur minimum des abscisses  \n",
    "mn=np.min(I_A)\n",
    "# valeur maximum des abscisses \n",
    "mx=np.max(I_A)\n",
    "\n",
    "I_mod = np.array([mn,mx])\n",
    "\n",
    "# Equation du modèle\n",
    "U_mod  =                      ## à compléter  ##############\n",
    "\n",
    "# Légende\n",
    "plt.plot(I_mod, U_mod,'-or', label=\"modélisation des données\")\n",
    "plt.plot(I_A, U_V, \"b+\", label=\"données expérimentales\")\n",
    "\n",
    "# Ecriture scientifique pour l'affichage de l'intensité\n",
    "plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))\n",
    "\n",
    "plt.xlabel(\"I (A)\")\n",
    "plt.ylabel(\"U (V)\")\n",
    "plt.legend() \n",
    "plt.title(\"Tension délivrée en fonction de l'intensité appelée\")\n",
    "\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-warning'><h4>Mise en forme du graphe</h4></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Choix de la taille du graphique et affichage du quadrillage\n",
    "plt.figure (figsize = (10,10))\n",
    "plt.grid()\n",
    "\n",
    "# Tracé avec affichage de l'équation de la droite\n",
    "plt.plot(I_mod, U_mod,'-r',label=\"modélisation des données\")\n",
    "plt.plot(I_A, U_V, \"b+\", label=\"données expérimentales\")\n",
    "\n",
    "# Ecriture scientifique pour l'affichage de l'intensité\n",
    "plt.ticklabel_format(style='scientific', axis='x', scilimits=(0,0))\n",
    "plt.xlabel(\"I (A)\")\n",
    "plt.ylabel(\"U (V)\")\n",
    "plt.legend() \n",
    "plt.title(\"Tension délivrée en fonction de l'intensité appelée\")\n",
    "\n",
    "# Affichage de la pente et de l'ordonnée à l'origine sur le graphique\n",
    "#(le signe multiplié est codé par le caractère Unicode 215) dans une boite de texte.\n",
    "# On renseigne les coordonnées d'affichage de la boite de texte et le texte à afficher\n",
    "plt.text(0.0001,1.2,\"U=\" + str(ordonnee_origine_a)+ str(pente_a)+ chr(215)+\"I\"\n",
    "        ,size=12,  \n",
    "         # On crée une boite aux coins ronds, au bord noir et remplie en cyan \n",
    "         bbox=dict(boxstyle=\"round\",ec=(\"k\"),fc=(\"c\")))\n",
    "\n",
    "plt.savefig('source-tension_U_I.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class = 'alert alert-success'><h4>La commande suivante imprime toutes les lignes de code exécutées depuis la dernière initialisation de la page (Restart and Clear Output)</h4></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%history"
   ]
  }
 ],
 "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": 2
}