{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "# Capacité numérique\n",
    "# Stick-slip et vibrations d'une corde de violon"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Nom :"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slip-Stick : Modélisation d'une corde de violon\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "<a href=https://simon-laurette.github.io/CN3_SlipStick/StickSlip.mp4><img src=\"https://simon-laurette.github.io/CN3_SlipStick/video.png\" width=\"400\" height=\"200\"></a>\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditions initiales\n",
    "\n",
    "Dans un premier temps, on va exécuter le code ci-dessous, qui importe les modules Python nécessaires. Les valeurs numériques des différents paramètres du problème sont rentrées dans les unités du système international."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from math import sqrt\n",
    "\n",
    "v0=0.01  # en m/s\n",
    "fs=0.8\n",
    "fd=0.7\n",
    "\n",
    "k=40000 # en N/m\n",
    "\n",
    "m=0.1  # en kg  liée à la pression exercée \n",
    "g=9.81    # en m/s2\n",
    "\n",
    "\n",
    "t=[0] # t correspond à la liste des instants de calcul de la position x et de la vitesse xp (pour \"xpoint\")\n",
    "tf=0.1 # en s, instant final de l'étude\n",
    "dt=0.00001 # dt est le pas de calcul en s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 1**\n",
    "> Rappeler le compromis à faire sur le choix de $dt$ pour qu'il soit adapté à la résolution numérique."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a ensuite besoin d'une variable ```etat``` qui indiquera l'état dans lequel se situe S2 :\n",
    "- l'état d'adhérence sera caractérisé par ```etat=0```\n",
    "- l'état de glissement sera caractérisé par ```etat=1```\n",
    "\n",
    "Par ailleurs, on va créer deux listes : ```l_x```et ```l_xp``` correspondant aux valeurs de $x$ et $\\frac{dx}{dt}$ évalués aux instants indiqués dans la liste ```t```. On aura donc :\n",
    "$$\\mbox{l_x[i]}=x\\left(t=t[i]\\right)$$\n",
    "$$\\mbox{l_xp[i]}=\\frac{dx}{dt}(t=t[i])$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Question 2**\n",
    "> Compléter le code suivant pour définir l'état initial, correspondant au solide S1, placé sur le tapis, adhérent, en x=0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "etat=                #à compléter\n",
    "l_x=[0]\n",
    "l_xp=                #à compléter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Détermination de l'état du système\n",
    "\n",
    "Le problème à résoudre est donc :\n",
    "\n",
    "<img src=\"https://simon-laurette.github.io/CN3_SlipStick/algo2.png\" width=\"500\" height=\"250\">\n",
    "\n",
    "Ainsi, à chaque nouvelle estimation de $x$ et $\\frac{dx}{dt}$, il faut vérifier si le système reste dans le même état ou s'il change d'état.\n",
    "\n",
    "On définit alors la fonction ```state(x,xp,etat)``` qui retourne la valeur actualisée de ```etat``` à partir de la position ```x``` et de la vitesse ```xp```, nouvellement calculées, de S2.\n",
    "\n",
    "**Question 3**\n",
    "> Compléter le code suivant qui définit la fonction ```state```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def state(x,xp,etat):\n",
    "        if etat==1 and xp>v0:\n",
    "            return               #à compléter\n",
    "        elif        and         :  #à compléter\n",
    "            return 1\n",
    "        else : \n",
    "            return               #à compléter\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Résolution en cas d'adhérence\n",
    "\n",
    "Lorque S2 est en état d'adhérence, il faut résoudre :\n",
    "$$\\frac{dx}{dt}=v_0$$\n",
    "\n",
    "**Question 4**\n",
    "> Discrétiser cette équation pour donner la relation entre ```l_x[i+1]```, ```l_x[i]``` et les autres paramètres du problème, lors de l'état d'adhérence."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Résolution en cas de glissement\n",
    "\n",
    "Lors du glissement de S2, il faut résoudre l'équation d'ordre 2 :\n",
    "\n",
    "$$m \\frac{d^2x}{dt^2}=- kx+f_d mg$$\n",
    "\n",
    "Pour résoudre ce type d'équation avec la méthode d'Euler, on va se ramener à une équation différentielle d'ordre 1, en posant le vecteur :\n",
    "$$Y= \\begin{bmatrix} x \\\\ \\dot{x}\\end{bmatrix}$$\n",
    "\n",
    "**Question 5**\n",
    "> Montrer que $Y$ suit une équation différentielle d'ordre 1 de type :\n",
    "> $$\\dot{Y} = F(Y)$$ \n",
    "> où $ F : \\mathbb{R}^2 \\rightarrow \\mathbb{R}^2$ est une fonction dont on donnera l'expression $F(u,v)$ et dont l'on complètera la définition dans le code ci-dessous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def F(u,v):\n",
    "    return               #à compléter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Résolution entière\n",
    "\n",
    "**Question 6**\n",
    "> Compléter le code ci-dessous pour effectuer la résolution du problème et l'affichage de la position et la vitesse au cours du temps. A quoi correspondent les traits horizontaux présents dans les deux tracés ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_etat=[etat]\n",
    "\n",
    "while t[-1]<tf :    \n",
    "    etat=state(l_x[-1],l_xp[-1],etat)\n",
    "    l_etat.append(etat)\n",
    "    if etat==0 :\n",
    "        #à compléter\n",
    "        l_x.append()\n",
    "        l_xp.append()\n",
    "    else :\n",
    "        a,b=F(l_x[-1],l_xp[-1])\n",
    "        #à compléter\n",
    "        l_x.append()\n",
    "        l_xp.append()\n",
    "    #à compléter\n",
    "    t.append()\n",
    "    \n",
    "############################################################################################################\n",
    "###########################           ne pas modifier             ##########################################\n",
    "############################################################################################################\n",
    "plt.close()\n",
    "plt.figure()\n",
    "plt.subplot(311)\n",
    "plt.plot(t,l_x,t,[fs*m*g/k]*len(t))\n",
    "plt.xlabel(\"Temps en secondes\")\n",
    "plt.ylabel(\"Position x en m\")    \n",
    "plt.grid()\n",
    "plt.subplot(312)\n",
    "plt.plot(t,l_xp,t,[v0]*len(t))\n",
    "plt.xlabel(\"Temps en secondes\")\n",
    "plt.ylabel(\"Vitesse de S2 en m/s\")\n",
    "plt.grid()\n",
    "plt.subplot(313)\n",
    "plt.plot(t,l_etat)\n",
    "plt.xlabel(\"Temps en secondes\")\n",
    "plt.ylabel(\"Etat de S2\")\n",
    "\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Analyse des résultats\n",
    "\n",
    "A l'aide du code suivant, on peut déterminer le spectre du signal $x(t)$.\n",
    "\n",
    "**Question 7**\n",
    "> Exécuter le code et expliquer avec précision ce qu'il fait.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_x=np.array(l_x)\n",
    "n=t_x.size\n",
    "\n",
    "spectre=np.fft.fft(t_x) # calcul du spectre\n",
    "freq=np.fft.fftfreq(n,d=dt) # création de la liste des fréquences où est calculé le spectre.\n",
    "\n",
    "plt.close()\n",
    "plt.figure()\n",
    "plt.plot(freq[0:int(len(freq)/100)],np.abs(spectre[0:int(len(freq)/100)]))\n",
    "# on réduit la liste des fréquences pour la visualisation\n",
    "plt.xlabel(\"Fréquence en Hz\")\n",
    "plt.ylabel(\"Spectre en Amplitude\")\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "max_spec=np.max(np.abs(spectre[1:int(len(freq)/100)]))\n",
    "for i in range(1,int(len(freq)/100)):\n",
    "    if np.abs(spectre)[i]==max_spec:\n",
    "        imax=i\n",
    "            \n",
    "f=freq[imax]\n",
    "print(\"La fréquence du slip-stick est\",str(f)[0:4],\"Hz\")"
   ]
  },
  {
   "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.9.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
