P3Delta_Online.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "hide-input"
    ]
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from IPython.core.display import display, HTML\n",
    "display(HTML(\"<style>div.output_scroll { height: 55em; }</style>\"))\n",
    "%matplotlib notebook\n",
    "import numpy as np\n",
    "import sympy as sp\n",
    "import cxroots as cx\n",
    "import scipy.special as spsp\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.colors as clr\n",
    "import matplotlib.cm as cm\n",
    "import ipywidgets as widgets\n",
    "from IPython.display import display\n",
    "from IPython.display import Markdown\n",
    "import traceback\n",
    "from IPython.display import HTML\n",
    "\n",
    "HTML('''<script>\n",
    "code_show=true; \n",
    "function code_toggle() {\n",
    " if (code_show){\n",
    " $('div.input').hide();\n",
    " } else {\n",
    " $('div.input').show();\n",
    " }\n",
    " code_show = !code_show\n",
    "} \n",
    "$( document ).ready(code_toggle);\n",
    "</script>\n",
    "The raw code of P3Delta Online is by default hidden for easier reading.\n",
    "To toggle on/off the raw code, click <a href=\"javascript:code_toggle()\">here</a>.''')\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>div.output_scroll { height: 55em; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "2ec7266f2f24484ba42a090156eb48a5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Image(value=b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x07\\x80\\x00\\x00\\x01,\\x08\\x02\\x00\\x00\\…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# -----------------------------------------------------------------------------\n",
    "# Global variable use in function, do not touch !\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "a_coeff_mid_generic = []\n",
    "b_coeff_mid_generic = []\n",
    "a_coeff_mid_co = []\n",
    "b_coeff_mid_co = []\n",
    "a_coeff_crrid_generic = []\n",
    "b_coeff_crrid_generic = []\n",
    "computedtau = 0\n",
    "computeds0 = 0\n",
    "liste_s0_sensitivity_max = 0\n",
    "liste_s0_sensitivity_min = 0\n",
    "liste_tau_sensitivity_max = 0\n",
    "liste_tau_sensitivity_min = 0\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "# Computation function for back-end\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "\n",
    "def compute_root_spectrum_mid_generic(n, m, s0, value_tau):\n",
    "    global a_coeff_mid_generic\n",
    "    global b_coeff_mid_generic\n",
    "    s = sp.symbols('s')\n",
    "    tau = sp.symbols('tau')\n",
    "    a = sp.symbols([\"a{:d}\".format(i) for i in range(n)], real=True)\n",
    "    alpha = sp.symbols([\"alpha{:d}\".format(i) for i in range(m + 1)],\n",
    "                       real=True)\n",
    "    polynomial = s ** n + np.array(a).dot([s ** i for i in range(n)])\n",
    "    delayed = np.array(alpha).dot([s ** i for i in range(m + 1)]) * sp.exp(\n",
    "        -s * tau)\n",
    "    q = polynomial + delayed\n",
    "    sysderivatif = [q]\n",
    "    for i in range(n + m + 1):\n",
    "        dernierederivee = sysderivatif[-1]\n",
    "        sysderivatif.append(dernierederivee.diff(s))\n",
    "    sol = sp.linsolve(sysderivatif[:-1], alpha + a).args[0]\n",
    "    solnum = sol.subs({s: s0})\n",
    "    solnum = solnum.subs({tau: value_tau})\n",
    "    a_num = list(solnum[m + 1:])\n",
    "    a_coeff_mid_generic = a_num.copy()\n",
    "    a_coeff_mid_generic.append(1)\n",
    "    alpha_num = list(solnum[:m + 1])\n",
    "    b_coeff_mid_generic = alpha_num.copy()\n",
    "    qnumerique = s ** n + np.array(a_num).dot([s ** i for i in range(n)]) + \\\n",
    "        np.array(alpha_num).dot([s ** i for i in range(m + 1)]) * \\\n",
    "        sp.exp(-s * tau)\n",
    "    qnumerique = qnumerique.subs(tau, value_tau)\n",
    "    sysrootfinding = [qnumerique, qnumerique.diff(s)]\n",
    "    sysfunc = [sp.lambdify(s, i) for i in sysrootfinding]\n",
    "    rect = cx.Rectangle([-100, 10], [-100, 100])\n",
    "    roots = rect.roots(sysfunc[0], sysfunc[1], rootErrTol=1e-5, absTol=1e-5,\n",
    "                       M=n + m + 1)\n",
    "    xroot = np.real(roots[0])\n",
    "    yroot = np.imag(roots[0])\n",
    "    return xroot, yroot, qnumerique\n",
    "\n",
    "\n",
    "def factorization_integral_latex(n, m, s0, tau):\n",
    "    factor = str(tau ** (m + 1) / spsp.factorial(m))\n",
    "    parenthesis = \"(s + \" + str(-s0) + \")\"\n",
    "    power = \"^{\" + str(n + m + 1) + \"}\"\n",
    "    return r\"\\$\" + \"\\\\Delta(s) = \" + factor + parenthesis + power + \\\n",
    "           r\"\\int_0^1 t^{\" + str(m) + r\"} (1 - t)^{\" + str(n) + \\\n",
    "           \"} e^{-\" + str(tau) + \"t\" + parenthesis + \\\n",
    "           \"} \\\\mathrm{d}t\" + \"$\"\n",
    "\n",
    "\n",
    "def factorization_1f1_latex(n, m, s0, tau):\n",
    "    factor = str(\n",
    "        tau ** (m + 1) * spsp.factorial(n) / spsp.factorial(n + m + 1))\n",
    "    parenthesis = \"(s + \" + str(-s0) + \")\"\n",
    "    power = \"^{\" + str(n + m + 1) + \"}\"\n",
    "    return r\"\\$\" + \"\\\\Delta(s) = \" + factor + parenthesis + power + \\\n",
    "           r\" {}_1 F_1(\" + str(m + 1) + r\", \" + str(n + m + 2) + \", -\" + \\\n",
    "           str(tau) + parenthesis + \")\" + \"$\"\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "def compute_admissibilite(n, m, a_coeff_mid_co):\n",
    "    s = sp.symbols('s')\n",
    "    tau = sp.symbols('tau')\n",
    "    a = sp.symbols([\"a{:d}\".format(i) for i in range(n)], real=True)\n",
    "    alpha = sp.symbols([\"alpha{:d}\".format(i) for i in range(m + 1)],\n",
    "                       real=True)\n",
    "    avalue = a_coeff_mid_co\n",
    "    polynomial = s ** n + np.array(a).dot([s ** i for i in range(n)])\n",
    "    delayed = np.array(alpha).dot([s ** i for i in range(m + 1)]) * sp.exp(\n",
    "        -s * tau)\n",
    "    q = polynomial + delayed\n",
    "    sysderivatif = [q]\n",
    "    for i in range(m + 1):\n",
    "        dernierederivee = sysderivatif[-1]\n",
    "        sysderivatif.append(dernierederivee.diff(s))\n",
    "    sol = sp.linsolve(sysderivatif[:-1], alpha).args[0]\n",
    "    polyadm = sysderivatif[-1].subs(\n",
    "        {alph: alphacoef for alph, alphacoef in zip(alpha, sol)})\n",
    "    polyadm = polyadm.subs({asymb: aval for asymb, aval in zip(a, avalue)})\n",
    "    polyadm = sp.simplify(polyadm)\n",
    "    s0range = np.arange(-10, 0, 0.01)\n",
    "    taurange = np.arange(0, 10, 0.01)\n",
    "    return s0range, taurange, polyadm, s, tau, q, avalue, sysderivatif, \\\n",
    "        alpha, a, sol\n",
    "\n",
    "\n",
    "def compute_root_spectrum_mid_co(n, m, value_tau):\n",
    "    global a_coeff_mid_co\n",
    "    global b_coeff_mid_co\n",
    "    s = sp.symbols('s')\n",
    "    tau = sp.symbols('tau')\n",
    "    a = sp.symbols([\"a{:d}\".format(i) for i in range(n)], real=True)\n",
    "    alpha = sp.symbols([\"alpha{:d}\".format(i) for i in range(m + 1)],\n",
    "                       real=True)\n",
    "    polynomial = s ** n + np.array(a).dot([s ** i for i in range(n)])\n",
    "    delayed = np.array(alpha).dot([s ** i for i in range(m + 1)]) * sp.exp(\n",
    "        -s * tau)\n",
    "    q = polynomial + delayed\n",
    "    sysderivatif = [q]\n",
    "    for i in range(n + m + 1):\n",
    "        dernierederivee = sysderivatif[-1]\n",
    "        sysderivatif.append(dernierederivee.diff(s))\n",
    "    a_num = a_coeff_mid_co.copy()\n",
    "    a_coeff_mid_co.append(1)\n",
    "    alpha_num = b_coeff_mid_co.copy()\n",
    "    qnumerique = s ** n + np.array(a_num).dot([s ** i for i in range(n)]) + \\\n",
    "        np.array(alpha_num).dot([s ** i for i in range(m + 1)]) * \\\n",
    "        sp.exp(-s * tau)\n",
    "    qnumerique = qnumerique.subs(tau, value_tau)\n",
    "    sysrootfinding = [qnumerique, qnumerique.diff(s)]\n",
    "    sysfunc = [sp.lambdify(s, i) for i in sysrootfinding]\n",
    "    rect = cx.Rectangle([-100, 10], [-100, 100])\n",
    "    roots = rect.roots(sysfunc[0], sysfunc[1], rootErrTol=1e-5, absTol=1e-5,\n",
    "                       M=n + m + 1)\n",
    "    xroot = np.real(roots[0])\n",
    "    yroot = np.imag(roots[0])\n",
    "    return xroot, yroot, qnumerique\n",
    "\n",
    "\n",
    "def getroots(m, q, delay, avalue, alphavalue, xwindow, ywindow, s, a, alpha,\n",
    "             tau):\n",
    "    derivees = [q, q.diff(s)]\n",
    "    for i in range(len(derivees)):\n",
    "        derivees[i] = derivees[i].subs(\n",
    "            {ai: ai_num for ai, ai_num in zip(a, avalue)})\n",
    "        derivees[i] = derivees[i].subs(\n",
    "            {alphai: alphai_num for alphai, alphai_num in\n",
    "             zip(alpha, alphavalue)})\n",
    "        derivees[i] = derivees[i].subs({tau: delay})\n",
    "    func = [sp.lambdify(s, i) for i in derivees]\n",
    "    rect = cx.Rectangle(xwindow, ywindow)\n",
    "    roots = rect.roots(func[0], func[1], rootErrTol=1e-5, absTol=1e-5, M=m + 2)\n",
    "    xroot, yroot = np.real(roots[0]), np.imag(roots[0])\n",
    "    return xroot, yroot, func\n",
    "\n",
    "\n",
    "def solve_tau_connu(tau_val, acoef, q, m, s, sysderivatif, alpha, a, tau):\n",
    "    sys = [q]\n",
    "    for i in range(m + 1):\n",
    "        dernierederivee = sys[-1]\n",
    "        sys.append(dernierederivee.diff(s))\n",
    "    sol = sp.linsolve(sysderivatif[:-1], alpha).args[0]\n",
    "    finaleq = sysderivatif[-1].subs(\n",
    "        {alph: alphacoef for alph, alphacoef in zip(alpha, sol)})\n",
    "    finaleq = finaleq.subs({asymb: aval for asymb, aval in zip(a, acoef)})\n",
    "    sols0 = finaleq.subs({tau: tau_val})\n",
    "    sols0 = sp.solve(sols0)\n",
    "    sols0eval = [i.evalf() for i in sols0]\n",
    "    try:\n",
    "        solution = max([i for i in sols0eval if i < 0])\n",
    "    except Exception:\n",
    "        traceback.print_exc()\n",
    "    return solution\n",
    "\n",
    "\n",
    "def compute_sensibilite(value_tau, q, m, s, sysderivatif, alpha, a, tau):\n",
    "    global a_coeff_mid_co\n",
    "    tau_nominal = value_tau\n",
    "    step = 1e-2\n",
    "    nbit = 10\n",
    "    values = [0] + [-step * i for i in range(1, nbit + 1)] + [step * i for i in\n",
    "                                                              range(1,\n",
    "                                                                    nbit + 1)]\n",
    "    values.sort()\n",
    "    tau_sens = []\n",
    "    s0_sens = []\n",
    "    for value in values:\n",
    "        tau_sens.append(tau_nominal + value)\n",
    "        s0_sens.append(solve_tau_connu(tau_sens[-1], a_coeff_mid_co, q, m, s,\n",
    "                                       sysderivatif, alpha, a, tau))\n",
    "    normaliser = clr.Normalize(min(tau_sens), max(tau_sens))\n",
    "    colormapper = cm.ScalarMappable(norm=normaliser,\n",
    "                                    cmap=plt.get_cmap(\"rainbow\"))\n",
    "    colormapper.set_array(tau_sens)\n",
    "    return tau_sens, s0_sens, colormapper\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "def compute_crrid_generic_root(n, m, s0, d, value_tau):\n",
    "    global a_coeff_crrid_generic\n",
    "    global b_coeff_crrid_generic\n",
    "    slist = [s0 - i * d for i in range(n + m + 1)]\n",
    "    s = sp.symbols('s')\n",
    "    tau = sp.symbols('tau')\n",
    "    a = sp.symbols([\"a{:d}\".format(i) for i in range(n)], real=True)\n",
    "    alpha = sp.symbols([\"alpha{:d}\".format(i) for i in range(m + 1)],\n",
    "                       real=True)\n",
    "    polynomial = s ** n + np.array(a).dot([s ** i for i in range(n)])\n",
    "    delayed = np.array(alpha).dot([s ** i for i in range(m + 1)]) * sp.exp(\n",
    "        -s * tau)\n",
    "    q = polynomial + delayed\n",
    "    sys = [q] * (n + m + 1)\n",
    "    for i in range(n + m + 1):\n",
    "        sys[i] = sys[i].subs({s: slist[i]})\n",
    "        sys[i] = sys[i].subs({tau: value_tau})\n",
    "    sol = sp.linsolve(sys, alpha + a).args[0]\n",
    "    solnum = sol.subs({tau: value_tau})\n",
    "    a_num = list(solnum[m + 1:])\n",
    "    a_coeff_crrid_generic = a_num.copy()\n",
    "    a_coeff_crrid_generic.append(1)\n",
    "    alpha_num = list(solnum[:m + 1])\n",
    "    b_coeff_crrid_generic = alpha_num.copy()\n",
    "    qnumerique = s ** n + np.array(a_num).dot([s ** i for i in range(n)]) + \\\n",
    "        np.array(alpha_num).dot(\n",
    "            [s ** i for i in range(m + 1)]) * sp.exp(-s * tau)\n",
    "    qnumerique = qnumerique.subs(tau, value_tau)\n",
    "    sysrootfinding = [qnumerique, qnumerique.diff(s)]\n",
    "    sysfunc = [sp.lambdify(s, i) for i in sysrootfinding]\n",
    "    rect = cx.Rectangle([-100, 10], [-100, 100])\n",
    "    roots = rect.roots(sysfunc[0], sysfunc[1], rootErrTol=1e-5, absTol=1e-5,\n",
    "                       M=n + m + 1)\n",
    "    xroot = np.real(roots[0])\n",
    "    yroot = np.imag(roots[0])\n",
    "    return xroot, yroot, qnumerique\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "def explicit_euler(n, tau, acoef, bcoef, t_final, n_iter, init_type,\n",
    "                   init_args):\n",
    "    while acoef.size < n:\n",
    "        acoef = np.append(acoef, 0)\n",
    "    a0 = np.diag(np.ones(n - 1), 1)\n",
    "    a0[-1, :] = -1 * acoef\n",
    "    while bcoef.size < n:\n",
    "        bcoef = np.append(bcoef, 0)\n",
    "    a1 = np.zeros((n, n))\n",
    "    a1[-1, :] = -1 * bcoef\n",
    "    dt = t_final / (n_iter - 1)\n",
    "    npast = int(np.ceil(tau / dt))\n",
    "    dt = tau / npast\n",
    "    time = np.linspace(start=float(tau), stop=t_final, num=n_iter)\n",
    "    sol = np.zeros((n, time.size))\n",
    "    sol[:, :(npast + 1)] = initial_solution(init_type, init_args, n,\n",
    "                                            time[:(npast + 1)])\n",
    "    for i in range(npast, time.size - 1):\n",
    "        sol[:, i + 1] = sol[:, i] + dt * (\n",
    "                a0.dot(sol[:, i]) + a1.dot(sol[:, i - npast]))\n",
    "    return time, sol\n",
    "\n",
    "\n",
    "def initial_solution(init_type, init_args, n, t):\n",
    "    x = sp.symbols('x')\n",
    "    if init_type == 'Constant':\n",
    "        y0 = np.zeros((n, t.size))\n",
    "        y0[0, :] = init_args\n",
    "        return y0\n",
    "\n",
    "    elif init_type == 'Polynomial':\n",
    "\n",
    "        degree = init_args[0]\n",
    "        p = np.array(init_args[1:]).dot([x ** i for i in range(degree + 1)])\n",
    "        derivees = []\n",
    "        y0 = np.zeros((n, t.size))\n",
    "        for i in range(n):\n",
    "            if i == 0:\n",
    "                derivees.append(p)\n",
    "            else:\n",
    "                derivees.append(derivees[-1].diff(x))\n",
    "            for j in range(t.size):\n",
    "                y0[i, j] = derivees[i].subs({x: t[j]})\n",
    "        return y0\n",
    "\n",
    "    elif init_type == 'Exponential':\n",
    "        gain = init_args[0]\n",
    "        exponant = init_args[1]\n",
    "        e = gain * sp.exp(exponant * x)\n",
    "        derivees = []\n",
    "        y0 = np.zeros((n, t.size))\n",
    "        for i in range(n):\n",
    "            if i == 0:\n",
    "                derivees.append(e)\n",
    "            else:\n",
    "                derivees.append(derivees[-1].diff(x))\n",
    "            for j in range(t.size):\n",
    "                y0[i, j] = derivees[i].subs({x: t[j]})\n",
    "        return y0\n",
    "\n",
    "    elif init_type == 'Trigonometric':\n",
    "        ampl = init_args[0]\n",
    "        freq = init_args[1]\n",
    "        phase = init_args[2]\n",
    "        tt = ampl * sp.sin(freq * x + phase)\n",
    "        derivees = []\n",
    "        y0 = np.zeros((n, t.size))\n",
    "        for i in range(n):\n",
    "            if i == 0:\n",
    "                derivees.append(tt)\n",
    "            else:\n",
    "                derivees.append(derivees[-1].diff(x))\n",
    "            for j in range(t.size):\n",
    "                y0[i, j] = derivees[i].subs({x: t[j]})\n",
    "        return y0\n",
    "    else:\n",
    "        pass\n",
    "\n",
    "\n",
    "def initialsolution(degn, delay, acoef, bcoef, t_final, n_iter, init_type,\n",
    "                    init_args):\n",
    "    acoef = np.array(acoef[:-1])\n",
    "    bcoef = np.array(bcoef)\n",
    "    time, sol = explicit_euler(degn, delay, acoef, bcoef, t_final, n_iter,\n",
    "                               init_type, init_args)\n",
    "    return time, sol\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "# Output\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "output_compute_analysis_mid_generic = widgets.Output()\n",
    "output_time_simulation_computation_mid_generic = widgets.Output()\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "output_admissibilite_computation_mid_co = widgets.Output()\n",
    "output_compute_analysis_mid_co = widgets.Output()\n",
    "output_sensibilite_computation_mid_co = widgets.Output()\n",
    "output_time_simulation_computation_mid_co = widgets.Output()\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "output_compute_analysis_mid_crrid_generic = widgets.Output()\n",
    "output_time_simulation_computation_1_crrid_generic = widgets.Output()\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "# User Interface input\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "slider_n_mid_generic = widgets.IntSlider(min=0, max=7, step=1,\n",
    "                                         description='n :', value=2)\n",
    "\n",
    "\n",
    "def slider_n_mid_generic_eventhandler(change):\n",
    "    slider_m_mid_generic.max = change.new\n",
    "    text_error_mid_generic.value = \"Be aware ! n should be higher \" \\\n",
    "                                   \"or equal to m ! \"\n",
    "\n",
    "\n",
    "slider_n_mid_generic.observe(slider_n_mid_generic_eventhandler, names='value')\n",
    "\n",
    "slider_m_mid_generic = widgets.IntSlider(min=0, max=7, step=1,\n",
    "                                         description='m :', value=1)\n",
    "\n",
    "floatext_s0_mid_generic = widgets.BoundedFloatText(min=-10.00, max=0.00,\n",
    "                                                   step=0.01,\n",
    "                                                   description='s0 :',\n",
    "                                                   value=-5.00, disabled=False)\n",
    "floattext_tau_mid_generic = widgets.BoundedFloatText(min=0.50, max=2.00,\n",
    "                                                     step=0.01,\n",
    "                                                     description='tau :',\n",
    "                                                     value=1.00,\n",
    "                                                     disabled=False)\n",
    "\n",
    "button_ready_to_compute_mid_generic = widgets.Button(\n",
    "    description='Compute analysis', layout=widgets.Layout(width='auto'),\n",
    "    disabled=False, button_style='warning',\n",
    "    icon='check-circle')\n",
    "intprogress_1_mid_generic = widgets.IntProgress(\n",
    "    layout=widgets.Layout(width='auto'), value=0, min=0, max=10,\n",
    "    description='Loading  ', style={'bar_color': '#ff9800'},\n",
    "    orientation='horizontal')\n",
    "layout_validate_1_mid_generic = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_compute_mid_generic,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_1_mid_generic,\n",
    "    footer=None)\n",
    "\n",
    "text_error_mid_generic = widgets.Text(\n",
    "    value='It is all good',\n",
    "    placeholder='Information may appear here',\n",
    "    description='',\n",
    "    disabled=True,\n",
    "    layout=widgets.Layout(\n",
    "        width='auto'))\n",
    "\n",
    "constant_constant_mid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Constant :', disabled=False)\n",
    "\n",
    "p = 9\n",
    "items_floattext_polynomial_coef_mid_generic = [\n",
    "    widgets.BoundedFloatText(step=0.1, description='a' + str(i), value=1,\n",
    "                             disabled=False,\n",
    "                             layout=widgets.Layout(max_width='800px')) for i in\n",
    "    range(p - 1)]\n",
    "box_0_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_1_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_2_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1],\n",
    "     items_floattext_polynomial_coef_mid_generic[2]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_3_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1],\n",
    "     items_floattext_polynomial_coef_mid_generic[2],\n",
    "     items_floattext_polynomial_coef_mid_generic[3]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_4_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1],\n",
    "     items_floattext_polynomial_coef_mid_generic[2],\n",
    "     items_floattext_polynomial_coef_mid_generic[3],\n",
    "     items_floattext_polynomial_coef_mid_generic[4]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_5_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1],\n",
    "     items_floattext_polynomial_coef_mid_generic[2],\n",
    "     items_floattext_polynomial_coef_mid_generic[3],\n",
    "     items_floattext_polynomial_coef_mid_generic[4],\n",
    "     items_floattext_polynomial_coef_mid_generic[5]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_6_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1],\n",
    "     items_floattext_polynomial_coef_mid_generic[2],\n",
    "     items_floattext_polynomial_coef_mid_generic[3],\n",
    "     items_floattext_polynomial_coef_mid_generic[4],\n",
    "     items_floattext_polynomial_coef_mid_generic[5],\n",
    "     items_floattext_polynomial_coef_mid_generic[6]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_7_floattext_polynomial_coef_mid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_generic[0],\n",
    "     items_floattext_polynomial_coef_mid_generic[1],\n",
    "     items_floattext_polynomial_coef_mid_generic[2],\n",
    "     items_floattext_polynomial_coef_mid_generic[3],\n",
    "     items_floattext_polynomial_coef_mid_generic[4],\n",
    "     items_floattext_polynomial_coef_mid_generic[5],\n",
    "     items_floattext_polynomial_coef_mid_generic[6],\n",
    "     items_floattext_polynomial_coef_mid_generic[7]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "\n",
    "stacked = widgets.Stacked([box_0_floattext_polynomial_coef_mid_generic,\n",
    "                           box_1_floattext_polynomial_coef_mid_generic,\n",
    "                           box_2_floattext_polynomial_coef_mid_generic,\n",
    "                           box_3_floattext_polynomial_coef_mid_generic,\n",
    "                           box_4_floattext_polynomial_coef_mid_generic,\n",
    "                           box_5_floattext_polynomial_coef_mid_generic,\n",
    "                           box_6_floattext_polynomial_coef_mid_generic,\n",
    "                           box_7_floattext_polynomial_coef_mid_generic])\n",
    "polynomial_degree_mid_generic = widgets.Dropdown(description='degree : ',\n",
    "                                                 options=['0', '1', '2', '3',\n",
    "                                                          '4', '5', '6', '7'])\n",
    "widgets.jslink((polynomial_degree_mid_generic, 'index'),\n",
    "               (stacked, 'selected_index'))\n",
    "stacked_2_simulation_time_mid_generic = widgets.VBox(\n",
    "    [polynomial_degree_mid_generic, stacked])\n",
    "polynomial_mid_generic = widgets.HBox([stacked_2_simulation_time_mid_generic],\n",
    "                                      layout=widgets.Layout(width='auto'))\n",
    "\n",
    "exponential_exponant_mid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Exponant :', disabled=False)\n",
    "exponential_gain_mid_generic = widgets.BoundedFloatText(value=1, step=1,\n",
    "                                                        description='Gain :',\n",
    "                                                        disabled=False)\n",
    "exponential_mid_generic = widgets.HBox(\n",
    "    [exponential_exponant_mid_generic, exponential_gain_mid_generic],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "\n",
    "trigonometric_amplitude_mid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Amplitude :', disabled=False)\n",
    "trigonometric_frequency_mid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Frequency :', disabled=False)\n",
    "trigonometric_phase_mid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Phase :', disabled=False)\n",
    "trigonometric_mid_generic = widgets.HBox(\n",
    "    [trigonometric_amplitude_mid_generic, trigonometric_frequency_mid_generic,\n",
    "     trigonometric_phase_mid_generic], layout=widgets.Layout(width='auto'))\n",
    "\n",
    "stacked_mid_generic = widgets.Stacked(\n",
    "    [constant_constant_mid_generic, polynomial_mid_generic,\n",
    "     exponential_mid_generic, trigonometric_mid_generic])\n",
    "dropdown_mid_generic = widgets.Dropdown(\n",
    "    options=['Constant', 'Polynomial', 'Exponential', 'Trigonometric'])\n",
    "\n",
    "widgets.jslink((dropdown_mid_generic, 'index'),\n",
    "               (stacked_mid_generic, 'selected_index'))\n",
    "\n",
    "stacked_simulation_time_mid_generic = widgets.VBox(\n",
    "    [dropdown_mid_generic, stacked_mid_generic])\n",
    "\n",
    "floattext_simulation_time_mid_generic = widgets.BoundedFloatText(\n",
    "    min=10.0,\n",
    "    max=60.0,\n",
    "    step=0.1,\n",
    "    description='Simulation time :',\n",
    "    value=10.0,\n",
    "    disabled=False,\n",
    "    style={\n",
    "        'description_width': 'initial'})\n",
    "\n",
    "button_ready_to_simulation_time_mid_generic = widgets.Button(\n",
    "    description='Compute time simulation', layout=widgets.Layout(width='auto'),\n",
    "    disabled=False, button_style='danger', icon='check-circle')\n",
    "intprogress_2_mid_generic = widgets.IntProgress(\n",
    "    layout=widgets.Layout(width='auto'), value=0, min=0, max=10,\n",
    "    description='Loading  ', style={'bar_color': '#f84434'},\n",
    "    orientation='horizontal')\n",
    "layout_validate_2_mid_generic = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_simulation_time_mid_generic,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_2_mid_generic,\n",
    "    footer=None)\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "slider_n_mid_co = widgets.IntSlider(min=1, max=7, step=1, description='n :',\n",
    "                                    value=2)\n",
    "\n",
    "\n",
    "def slider_n_mid_co_eventhandler(change):\n",
    "    slider_m_mid_co.max = change.new\n",
    "\n",
    "\n",
    "slider_n_mid_co.observe(slider_n_mid_co_eventhandler, names='value')\n",
    "\n",
    "slider_m_mid_co = widgets.IntSlider(min=0, max=7, step=1, description='m :',\n",
    "                                    value=1)\n",
    "\n",
    "button_confirm_degrees_mid_co = widgets.Button(description='Confirm degrees',\n",
    "                                               layout=widgets.Layout(\n",
    "                                                   width='18%'),\n",
    "                                               disabled=False,\n",
    "                                               button_style='warning',\n",
    "                                               icon='angle-double-right')\n",
    "\n",
    "box_number = 9\n",
    "items_inttext_a_mid_co = [\n",
    "    widgets.BoundedIntText(min=-10, max=10, step=1, description='', value=0,\n",
    "                           disabled=True) for i in range(box_number - 1)]\n",
    "\n",
    "sub_list_1 = []\n",
    "sub_list_2 = []\n",
    "\n",
    "for k in range(0, 4):\n",
    "    sub_list_1.append(items_inttext_a_mid_co[k])\n",
    "\n",
    "for k in range(4, len(items_inttext_a_mid_co)):\n",
    "    sub_list_2.append(items_inttext_a_mid_co[k])\n",
    "\n",
    "inttext_a_1_mid_co = widgets.Box(children=sub_list_1,\n",
    "                                 layout=widgets.Layout(width='auto',\n",
    "                                                       max_width='81%',\n",
    "                                                       height=''))\n",
    "inttext_a_2_mid_co = widgets.Box(children=sub_list_2,\n",
    "                                 layout=widgets.Layout(width='auto',\n",
    "                                                       max_width='81%',\n",
    "                                                       height=''))\n",
    "\n",
    "button_confirm_system_coeff_mid_co = widgets.Button(\n",
    "    description='Confirm coefficients', layout=widgets.Layout(width='16%'),\n",
    "    disabled=False, button_style='warning', icon='angle-double-right')\n",
    "\n",
    "togglebuttons_mid_co = widgets.ToggleButtons(options=['tau', 's0'],\n",
    "                                             disabled=False, button_style='',\n",
    "                                             tooltips=['tau is known',\n",
    "                                                       's0 is known'])\n",
    "togglebuttons_mid_co.style.button_width = 'auto'\n",
    "\n",
    "\n",
    "def togglebuttons_mid_co_eventhandler(change):\n",
    "    if change.new == 's0':\n",
    "        floattext_s0_tau_mid_co.min, floattext_s0_tau_mid_co.max = \\\n",
    "            liste_s0_sensitivity_min, liste_s0_sensitivity_max\n",
    "        floattext_s0_tau_mid_co.step = 0.001\n",
    "        floattext_s0_tau_mid_co.value = -1.506\n",
    "        floattext_s0_tau_mid_co.description = 's0 : '\n",
    "    if change.new == 'tau':\n",
    "        floattext_s0_tau_mid_co.max, floattext_s0_tau_mid_co.min = \\\n",
    "            liste_tau_sensitivity_max, liste_tau_sensitivity_min\n",
    "        floattext_s0_tau_mid_co.step = 0.01\n",
    "        floattext_s0_tau_mid_co.value = 0.73\n",
    "        floattext_s0_tau_mid_co.description = 'tau : '\n",
    "\n",
    "\n",
    "togglebuttons_mid_co.observe(togglebuttons_mid_co_eventhandler, names='value')\n",
    "\n",
    "floattext_s0_tau_mid_co = widgets.BoundedFloatText(description='tau : ',\n",
    "                                                   disabled=True)\n",
    "\n",
    "button_ready_to_compute_mid_co = widgets.Button(description='Compute analysis',\n",
    "                                                layout=widgets.Layout(\n",
    "                                                    width='auto'),\n",
    "                                                disabled=False,\n",
    "                                                button_style='warning',\n",
    "                                                icon='check-circle')\n",
    "intprogress_1_mid_co = widgets.IntProgress(layout=widgets.Layout(width='auto'),\n",
    "                                           value=0, min=0, max=10,\n",
    "                                           description='Loading  ',\n",
    "                                           style={'bar_color': '#ff9c28'},\n",
    "                                           orientation='horizontal')\n",
    "layout_validate_1_mid_co = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_compute_mid_co,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_1_mid_co,\n",
    "    footer=None)\n",
    "\n",
    "text_error_mid_co = widgets.Text(value='It is all good',\n",
    "                                 placeholder='Information may appear here',\n",
    "                                 description='', disabled=True,\n",
    "                                 layout=widgets.Layout(width='auto'))\n",
    "\n",
    "constant_constant_mid_co = widgets.BoundedFloatText(value=1, step=1,\n",
    "                                                    description='Constant :',\n",
    "                                                    disabled=False)\n",
    "\n",
    "p = 9\n",
    "items_floattext_polynomial_coef_mid_co = [\n",
    "    widgets.BoundedFloatText(step=0.1, description='a' + str(i), value=1,\n",
    "                             disabled=False,\n",
    "                             layout=widgets.Layout(max_width='800px')) for i in\n",
    "    range(p - 1)]\n",
    "box_0_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_1_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_2_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1],\n",
    "     items_floattext_polynomial_coef_mid_co[2]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_3_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1],\n",
    "     items_floattext_polynomial_coef_mid_co[2],\n",
    "     items_floattext_polynomial_coef_mid_co[3]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_4_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1],\n",
    "     items_floattext_polynomial_coef_mid_co[2],\n",
    "     items_floattext_polynomial_coef_mid_co[3],\n",
    "     items_floattext_polynomial_coef_mid_co[4]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_5_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1],\n",
    "     items_floattext_polynomial_coef_mid_co[2],\n",
    "     items_floattext_polynomial_coef_mid_co[3],\n",
    "     items_floattext_polynomial_coef_mid_co[4],\n",
    "     items_floattext_polynomial_coef_mid_co[5]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_6_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1],\n",
    "     items_floattext_polynomial_coef_mid_co[2],\n",
    "     items_floattext_polynomial_coef_mid_co[3],\n",
    "     items_floattext_polynomial_coef_mid_co[4],\n",
    "     items_floattext_polynomial_coef_mid_co[5],\n",
    "     items_floattext_polynomial_coef_mid_co[6]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_7_floattext_polynomial_coef_mid_co = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_mid_co[0],\n",
    "     items_floattext_polynomial_coef_mid_co[1],\n",
    "     items_floattext_polynomial_coef_mid_co[2],\n",
    "     items_floattext_polynomial_coef_mid_co[3],\n",
    "     items_floattext_polynomial_coef_mid_co[4],\n",
    "     items_floattext_polynomial_coef_mid_co[5],\n",
    "     items_floattext_polynomial_coef_mid_co[6],\n",
    "     items_floattext_polynomial_coef_mid_co[7]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "\n",
    "stacked_mid_co = widgets.Stacked([box_0_floattext_polynomial_coef_mid_co,\n",
    "                                  box_1_floattext_polynomial_coef_mid_co,\n",
    "                                  box_2_floattext_polynomial_coef_mid_co,\n",
    "                                  box_3_floattext_polynomial_coef_mid_co,\n",
    "                                  box_4_floattext_polynomial_coef_mid_co,\n",
    "                                  box_5_floattext_polynomial_coef_mid_co,\n",
    "                                  box_6_floattext_polynomial_coef_mid_co,\n",
    "                                  box_7_floattext_polynomial_coef_mid_co])\n",
    "polynomial_degree_mid_co = widgets.Dropdown(description='degree : ',\n",
    "                                            options=['0', '1', '2', '3', '4',\n",
    "                                                     '5', '6', '7'])\n",
    "\n",
    "widgets.jslink((polynomial_degree_mid_co, 'index'),\n",
    "               (stacked_mid_co, 'selected_index'))\n",
    "stacked_2_simulation_time_mid_co = widgets.VBox(\n",
    "    [polynomial_degree_mid_co, stacked_mid_co])\n",
    "polynomial_mid_co = widgets.HBox([stacked_2_simulation_time_mid_co],\n",
    "                                 layout=widgets.Layout(width='auto'))\n",
    "\n",
    "exponential_exponant_mid_co = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Exponant :', disabled=False)\n",
    "exponential_gain_mid_co = widgets.BoundedFloatText(value=1, step=1,\n",
    "                                                   description='Gain :',\n",
    "                                                   disabled=False)\n",
    "exponential_mid_co = widgets.HBox(\n",
    "    [exponential_exponant_mid_co, exponential_gain_mid_co],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "\n",
    "trigonometric_amplitude_mid_co = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Amplitude :', disabled=False)\n",
    "trigonometric_frequency_mid_co = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Frequency :', disabled=False)\n",
    "trigonometric_phase_mid_co = widgets.BoundedFloatText(value=1, step=1,\n",
    "                                                      description='Phase :',\n",
    "                                                      disabled=False)\n",
    "trigonometric_mid_co = widgets.HBox(\n",
    "    [trigonometric_amplitude_mid_co, trigonometric_frequency_mid_co,\n",
    "     trigonometric_phase_mid_co], layout=widgets.Layout(width='auto'))\n",
    "\n",
    "stacked_mid_co = widgets.Stacked(\n",
    "    [constant_constant_mid_co, polynomial_mid_co, exponential_mid_co,\n",
    "     trigonometric_mid_co])\n",
    "dropdown_mid_co = widgets.Dropdown(\n",
    "    options=['Constant', 'Polynomial', 'Exponential', 'Trigonometric'])\n",
    "\n",
    "widgets.jslink((dropdown_mid_co, 'index'), (stacked_mid_co, 'selected_index'))\n",
    "\n",
    "stacked_simulation_time_mid_co = widgets.VBox(\n",
    "    [dropdown_mid_co, stacked_mid_co])\n",
    "\n",
    "floattext_simulation_time_mid_co = widgets.BoundedFloatText(\n",
    "    min=10.0,\n",
    "    max=60.0,\n",
    "    step=0.1,\n",
    "    description='Simulation time :',\n",
    "    value=10.0,\n",
    "    disabled=False,\n",
    "    style={\n",
    "        'description_width': 'initial'})\n",
    "\n",
    "button_ready_to_simulation_time_mid_co = widgets.Button(\n",
    "    description='Compute simulation', layout=widgets.Layout(width='auto'),\n",
    "    disabled=False, button_style='danger', icon='check-circle')\n",
    "intprogress_3_mid_co = widgets.IntProgress(layout=widgets.Layout(width='auto'),\n",
    "                                           value=0, min=0, max=10,\n",
    "                                           description='Loading  ',\n",
    "                                           style={'bar_color': '#f84434'},\n",
    "                                           orientation='horizontal')\n",
    "layout_validate_2_mid_co = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_simulation_time_mid_co,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_3_mid_co,\n",
    "    footer=None)\n",
    "\n",
    "button_ready_to_sensitivity_mid_co = widgets.Button(\n",
    "    description='Compute sensitivity (optional)',\n",
    "    layout=widgets.Layout(width='auto'), disabled=False, button_style='info',\n",
    "    icon='check-circle')\n",
    "intprogress_4_mid_co = widgets.IntProgress(layout=widgets.Layout(width='auto'),\n",
    "                                           value=0, min=0, max=10,\n",
    "                                           description='Loading  ',\n",
    "                                           style={'bar_color': '#10acd8'},\n",
    "                                           orientation='horizontal')\n",
    "layout_validate_3_mid_co = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_sensitivity_mid_co,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_4_mid_co,\n",
    "    footer=None)\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "slider_n_crrid_generic = widgets.IntSlider(min=1, max=7, step=1,\n",
    "                                           description='n :', value=2)\n",
    "\n",
    "\n",
    "def slider_n_crrid_generic_eventhandler(change):\n",
    "    slider_m_crrid_generic.max = change.new\n",
    "\n",
    "\n",
    "slider_n_crrid_generic.observe(slider_n_crrid_generic_eventhandler,\n",
    "                               names='value')\n",
    "slider_m_crrid_generic = widgets.IntSlider(min=0, max=7, step=1,\n",
    "                                           description='m :', value=1)\n",
    "slider_d_crrid_generic = widgets.IntSlider(min=0, max=5, step=1,\n",
    "                                           description='d :', value=2)\n",
    "\n",
    "floattext_s0_crrid_generic = widgets.BoundedFloatText(min=-10.00, max=0.00,\n",
    "                                                      step=0.01,\n",
    "                                                      description='s0 :',\n",
    "                                                      value=-1.00,\n",
    "                                                      disabled=False)\n",
    "floattext_tau_crrid_generic = widgets.BoundedFloatText(min=0.50, max=2.00,\n",
    "                                                       step=0.01,\n",
    "                                                       description='tau :',\n",
    "                                                       value=1.00,\n",
    "                                                       disabled=False)\n",
    "\n",
    "button_ready_to_compute_mid_crrid_generic = widgets.Button(\n",
    "    description='Compute analysis', layout=widgets.Layout(width='auto'),\n",
    "    disabled=False, button_style='warning',\n",
    "    icon='check-circle')\n",
    "intprogress_1_mid_crrid_generic = widgets.IntProgress(\n",
    "    layout=widgets.Layout(width='auto'), value=0, min=0, max=10,\n",
    "    description='Loading  ', style={'bar_color': '#ff9800'},\n",
    "    orientation='horizontal')\n",
    "layout_validate_1_mid_crrid_generic = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_compute_mid_crrid_generic,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_1_mid_crrid_generic,\n",
    "    footer=None)\n",
    "\n",
    "text_error_crrid_generic = widgets.Text(\n",
    "    value='It is all good',\n",
    "    placeholder='Information may appear here',\n",
    "    description='',\n",
    "    disabled=True,\n",
    "    layout=widgets.Layout(\n",
    "        width='auto'))\n",
    "\n",
    "constant_constant_crrid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Constant :', disabled=False)\n",
    "\n",
    "p = 9\n",
    "items_floattext_polynomial_coef_crrid_generic = [\n",
    "    widgets.BoundedFloatText(step=0.1, description='a' + str(i), value=1,\n",
    "                             disabled=False,\n",
    "                             layout=widgets.Layout(max_width='800px')) for i in\n",
    "    range(p - 1)]\n",
    "box_0_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_1_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_2_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1],\n",
    "     items_floattext_polynomial_coef_crrid_generic[2]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_3_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1],\n",
    "     items_floattext_polynomial_coef_crrid_generic[2],\n",
    "     items_floattext_polynomial_coef_crrid_generic[3]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_4_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1],\n",
    "     items_floattext_polynomial_coef_crrid_generic[2],\n",
    "     items_floattext_polynomial_coef_crrid_generic[3],\n",
    "     items_floattext_polynomial_coef_crrid_generic[4]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_5_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1],\n",
    "     items_floattext_polynomial_coef_crrid_generic[2],\n",
    "     items_floattext_polynomial_coef_crrid_generic[3],\n",
    "     items_floattext_polynomial_coef_crrid_generic[4],\n",
    "     items_floattext_polynomial_coef_crrid_generic[5]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_6_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1],\n",
    "     items_floattext_polynomial_coef_crrid_generic[2],\n",
    "     items_floattext_polynomial_coef_crrid_generic[3],\n",
    "     items_floattext_polynomial_coef_crrid_generic[4],\n",
    "     items_floattext_polynomial_coef_crrid_generic[5],\n",
    "     items_floattext_polynomial_coef_crrid_generic[6]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "box_7_floattext_polynomial_coef_crrid_generic = widgets.VBox(\n",
    "    [items_floattext_polynomial_coef_crrid_generic[0],\n",
    "     items_floattext_polynomial_coef_crrid_generic[1],\n",
    "     items_floattext_polynomial_coef_crrid_generic[2],\n",
    "     items_floattext_polynomial_coef_crrid_generic[3],\n",
    "     items_floattext_polynomial_coef_crrid_generic[4],\n",
    "     items_floattext_polynomial_coef_crrid_generic[5],\n",
    "     items_floattext_polynomial_coef_crrid_generic[6],\n",
    "     items_floattext_polynomial_coef_crrid_generic[7]],\n",
    "    layout=widgets.Layout(max_width='auto'))\n",
    "\n",
    "stacked = widgets.Stacked([box_0_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_1_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_2_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_3_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_4_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_5_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_6_floattext_polynomial_coef_crrid_generic,\n",
    "                           box_7_floattext_polynomial_coef_crrid_generic])\n",
    "polynomial_degree_crrid_generic = widgets.Dropdown(description='degree : ',\n",
    "                                                   options=['0', '1', '2', '3',\n",
    "                                                            '4', '5', '6',\n",
    "                                                            '7'])\n",
    "widgets.jslink((polynomial_degree_crrid_generic, 'index'),\n",
    "               (stacked, 'selected_index'))\n",
    "stacked_2_simulation_time_crrid_generic = widgets.VBox(\n",
    "    [polynomial_degree_crrid_generic, stacked])\n",
    "polynomial_crrid_generic = widgets.HBox(\n",
    "    [stacked_2_simulation_time_crrid_generic],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "\n",
    "exponential_exponant_crrid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Exponant :', disabled=False)\n",
    "exponential_gain_crrid_generic = widgets.BoundedFloatText(value=1, step=1,\n",
    "                                                          description='Gain :',\n",
    "                                                          disabled=False)\n",
    "exponential_crrid_generic = widgets.HBox(\n",
    "    [exponential_exponant_crrid_generic, exponential_gain_crrid_generic],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "\n",
    "trigonometric_amplitude_crrid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Amplitude :', disabled=False)\n",
    "trigonometric_frequency_crrid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Frequency :', disabled=False)\n",
    "trigonometric_phase_crrid_generic = widgets.BoundedFloatText(\n",
    "    value=1, step=1, description='Phase :', disabled=False)\n",
    "trigonometric_crrid_generic = widgets.HBox(\n",
    "    [trigonometric_amplitude_crrid_generic,\n",
    "     trigonometric_frequency_crrid_generic, trigonometric_phase_crrid_generic],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "\n",
    "stacked_crrid_generic = widgets.Stacked(\n",
    "    [constant_constant_crrid_generic, polynomial_crrid_generic,\n",
    "     exponential_crrid_generic, trigonometric_crrid_generic])\n",
    "dropdown_crrid_generic = widgets.Dropdown(\n",
    "    options=['Constant', 'Polynomial', 'Exponential', 'Trigonometric'])\n",
    "\n",
    "widgets.jslink((dropdown_crrid_generic, 'index'),\n",
    "               (stacked_crrid_generic, 'selected_index'))\n",
    "\n",
    "stacked_simulation_time_crrid_generic = widgets.VBox(\n",
    "    [dropdown_crrid_generic, stacked_crrid_generic])\n",
    "\n",
    "floattext_simulation_time_crrid_generic = widgets.BoundedFloatText(\n",
    "    min=10.0,\n",
    "    max=60.0,\n",
    "    step=0.1,\n",
    "    description='Simulation time :',\n",
    "    value=10.0,\n",
    "    disabled=False,\n",
    "    style={\n",
    "        'description_width': 'initial'})\n",
    "\n",
    "button_ready_to_simulation_time_crrid_generic = widgets.Button(\n",
    "    description='Compute time simulation', layout=widgets.Layout(width='auto'),\n",
    "    disabled=False, button_style='danger', icon='check-circle')\n",
    "intprogress_2_crrid_generic = widgets.IntProgress(\n",
    "    layout=widgets.Layout(width='auto'), value=0, min=0, max=10,\n",
    "    description='Loading  ', style={'bar_color': '#f84434'},\n",
    "    orientation='horizontal')\n",
    "layout_validate_2_crrid_generic = widgets.AppLayout(\n",
    "    header=None,\n",
    "    left_sidebar=button_ready_to_simulation_time_crrid_generic,\n",
    "    center=None,\n",
    "    right_sidebar=intprogress_2_crrid_generic,\n",
    "    footer=None)\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "# Computation function for front-end\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "def computation_1_mid_generic(n, m, s0, value_tau):\n",
    "    output_compute_analysis_mid_generic.clear_output()\n",
    "\n",
    "    with output_compute_analysis_mid_generic:\n",
    "\n",
    "        display(Markdown(\"<h3>Spectrum distribution</h3>\"))\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        ax.set_title(\"Spectrum distribution\")\n",
    "        ax.set_xlabel(r\"$\\Re(s)$\")\n",
    "        ax.set_ylabel(r\"$\\Im(s)$\")\n",
    "        ax.axhline(linewidth=2, color='black', zorder=2)\n",
    "        ax.axvline(linewidth=2, color='black', zorder=2)\n",
    "        ax.axvspan(0, 100, alpha=0.5, color='red', zorder=2,\n",
    "                   label='Unstable system')\n",
    "        ax.grid()\n",
    "        line, = ax.plot([], [], 'o', color='steelblue', zorder=3,\n",
    "                        label='Roots')\n",
    "        xr, yr, eq = compute_root_spectrum_mid_generic(n, m, s0, value_tau)\n",
    "        xmax = max(xr)\n",
    "        plt.xlim([-10, 1])\n",
    "        line.set_data(xr, yr)\n",
    "        xmax_round = round(xmax, 2)\n",
    "        line2, = ax.plot([], [], '*', markersize=20, color='#ff9900', zorder=3,\n",
    "                         label='Rightmost root (' + str(\n",
    "                             xmax_round) + ';' + '0' + ')')\n",
    "        line2.set_data(xmax, 0)\n",
    "        ax.legend(loc='upper right')\n",
    "        ax.relim()\n",
    "        fig.canvas.draw()\n",
    "\n",
    "        display(Markdown(\"<h3>Parameters</h3>\"))\n",
    "        print(\"n = \", slider_n_mid_generic.value, \", m = \",\n",
    "              slider_m_mid_generic.value, \", s0 = \",\n",
    "              floatext_s0_mid_generic.value, \", tau = \",\n",
    "              floattext_tau_mid_generic.value)\n",
    "        a_coeff_chain = \"\"\n",
    "        b_coeff_chain = \"\"\n",
    "        i = 0\n",
    "        for a_coeff in a_coeff_mid_generic:\n",
    "            a_coeff_chain = a_coeff_chain + \"a\" + str(i) + \" = \" + str(\n",
    "                a_coeff) + \", \"\n",
    "            i = i + 1\n",
    "        print(a_coeff_chain)\n",
    "        i = 0\n",
    "        for b_coeff in b_coeff_mid_generic:\n",
    "            b_coeff_chain = b_coeff_chain + \"b\" + str(i) + \" = \" + str(\n",
    "                b_coeff) + \", \"\n",
    "            i = i + 1\n",
    "        print(b_coeff_chain)\n",
    "\n",
    "        display(Markdown(\"<h3>Ouput equation</h3>\"))\n",
    "        print(\"Fp = \", eq)\n",
    "        display(Markdown(\"<h3>Factorized integral equation</h3>\"))\n",
    "        factorization_integral_latex_equation_mid_generic = \\\n",
    "            factorization_integral_latex(n, m, s0, value_tau)\n",
    "        display(Markdown(factorization_integral_latex_equation_mid_generic))\n",
    "        display(Markdown(\"<h3>Hypergeometric factorization</h3>\"))\n",
    "        factorization_1f1_latex_equation_mid_generic = factorization_1f1_latex(\n",
    "            n, m, s0, value_tau)\n",
    "        display(Markdown(factorization_1f1_latex_equation_mid_generic))\n",
    "\n",
    "\n",
    "def button_ready_to_compute_clicked_mid_generic(self):\n",
    "    n_mid_generic = slider_n_mid_generic.value\n",
    "    m_mid_generic = slider_m_mid_generic.value\n",
    "    s0_mid_generic = floatext_s0_mid_generic.value\n",
    "    tau_mid_generic = floattext_tau_mid_generic.value\n",
    "    computation_1_mid_generic(n_mid_generic, m_mid_generic, s0_mid_generic,\n",
    "                              tau_mid_generic)\n",
    "\n",
    "\n",
    "button_ready_to_compute_mid_generic.on_click(\n",
    "    button_ready_to_compute_clicked_mid_generic)\n",
    "\n",
    "\n",
    "def computation_2_mid_generic(degn, delay, acoef, bcoef, t_final, n_iter,\n",
    "                              init_type, init_args):\n",
    "    output_time_simulation_computation_mid_generic.clear_output()\n",
    "\n",
    "    with output_time_simulation_computation_mid_generic:\n",
    "        display(Markdown(\"<h3>Time simulation plot</h3>\"))\n",
    "\n",
    "        time_initsolution, sol_initsolution = initialsolution(degn, delay,\n",
    "                                                              acoef, bcoef,\n",
    "                                                              t_final, n_iter,\n",
    "                                                              init_type,\n",
    "                                                              init_args)\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        plt.plot(time_initsolution, sol_initsolution[0, :], '#f84434')\n",
    "        ax.grid()\n",
    "        plt.xlabel(r\"$t$ (in second)\", fontsize=12)\n",
    "        plt.ylabel(r\"$y(t)$\")\n",
    "        plt.title(\"Time simulation\")\n",
    "\n",
    "\n",
    "def button_ready_to_simulation_time_clicked_mid_generic(self):\n",
    "    degn = slider_n_mid_generic.value\n",
    "    delay = floattext_tau_mid_generic.value\n",
    "    acoef = a_coeff_mid_generic\n",
    "    bcoef = b_coeff_mid_generic\n",
    "    t_final = floattext_simulation_time_mid_generic.value\n",
    "    n_iter = 100000\n",
    "    init_type = dropdown_mid_generic.value\n",
    "\n",
    "    if init_type == 'Constant':\n",
    "        init_args = [constant_constant_mid_generic.value]\n",
    "\n",
    "    elif init_type == 'Polynomial':\n",
    "        init_args = [int(polynomial_degree_mid_generic.value)]\n",
    "\n",
    "        for i in range(int(polynomial_degree_mid_generic.value) + 1):\n",
    "            init_args.append(\n",
    "                items_floattext_polynomial_coef_mid_generic[i].value)\n",
    "\n",
    "    elif init_type == 'Exponential':\n",
    "        init_args = [exponential_gain_mid_generic.value,\n",
    "                     exponential_exponant_mid_generic.value]\n",
    "\n",
    "    elif init_type == 'Trigonometric':\n",
    "        init_args = [trigonometric_amplitude_mid_generic.value,\n",
    "                     trigonometric_frequency_mid_generic.value,\n",
    "                     trigonometric_phase_mid_generic.value]\n",
    "\n",
    "    computation_2_mid_generic(degn, delay, acoef, bcoef, t_final, n_iter,\n",
    "                              init_type, init_args)\n",
    "\n",
    "\n",
    "button_ready_to_simulation_time_mid_generic.on_click(\n",
    "    button_ready_to_simulation_time_clicked_mid_generic)\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "def computation_1_mid_co(n, m, a_coeff_mid_co):\n",
    "    global liste_s0_sensitivity_max\n",
    "    global liste_s0_sensitivity_min\n",
    "    global liste_tau_sensitivity_max\n",
    "    global liste_tau_sensitivity_min\n",
    "\n",
    "    output_admissibilite_computation_mid_co.clear_output()\n",
    "\n",
    "    with output_admissibilite_computation_mid_co:\n",
    "        s0range, taurange, polyadm, s, tau, q, avalue, sysderivatif, alpha, \\\n",
    "            a, sol = compute_admissibilite(n, m, a_coeff_mid_co)\n",
    "\n",
    "        s0range = np.arange(-16, 0, 0.01)\n",
    "        taurange = np.arange(0, 10, 0.01)\n",
    "\n",
    "        func = sp.lambdify([s, tau], polyadm)\n",
    "\n",
    "        display(Markdown(\"<h3>Admissibility plot</h3>\"))\n",
    "\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        x, y = np.meshgrid(s0range, taurange)\n",
    "        z = func(x, y)\n",
    "\n",
    "        cs = ax.contour(x, y, z, [0], colors='#ff9c28')\n",
    "        ax.grid()\n",
    "\n",
    "        plt.xlabel(r\"$s_0$\")\n",
    "        plt.ylabel(r\"$\\tau$\")\n",
    "        plt.title(\"Admissibility plot\")\n",
    "\n",
    "        p = cs.collections[0].get_paths()[0]\n",
    "        v = p.vertices\n",
    "        liste_s0_sensitivity = v[:, 0].copy()\n",
    "        liste_tau_sensitivity = v[:, 1].copy()\n",
    "\n",
    "        liste_s0_sensitivity_max = round(np.max(liste_s0_sensitivity), 5)\n",
    "        liste_s0_sensitivity_min = round(np.min(liste_s0_sensitivity), 5)\n",
    "        liste_tau_sensitivity_max = round(np.max(liste_tau_sensitivity), 5)\n",
    "        liste_tau_sensitivity_min = round(np.min(liste_tau_sensitivity), 5)\n",
    "\n",
    "        display(Markdown(\"<h3>s0 and tau limits</h3>\"))\n",
    "        display(Markdown(\n",
    "            r\"\\$\" + str(liste_s0_sensitivity_min) + \"\\\\leq s_0 \\\\leq \" + str(\n",
    "                liste_s0_sensitivity_max) + \"$\"))\n",
    "        display(Markdown(\n",
    "            r\"\\$\" + str(liste_tau_sensitivity_min) + \"\\\\leq tau \\\\leq \" + str(\n",
    "                liste_tau_sensitivity_max) + \"$\"))\n",
    "\n",
    "        floattext_s0_tau_mid_co.max = liste_tau_sensitivity_max\n",
    "        floattext_s0_tau_mid_co.min = liste_tau_sensitivity_min\n",
    "        floattext_s0_tau_mid_co.step = 0.01\n",
    "        floattext_s0_tau_mid_co.value = 0.73\n",
    "        floattext_s0_tau_mid_co.description = 'tau : '\n",
    "        floattext_s0_tau_mid_co.disabled = False\n",
    "\n",
    "\n",
    "def computation_2_mid_co(n, m, user_choice, user_value):\n",
    "    output_compute_analysis_mid_co.clear_output()\n",
    "\n",
    "    global a_coeff_mid_co\n",
    "    global b_coeff_mid_co\n",
    "    global computedtau\n",
    "    global computeds0\n",
    "\n",
    "    with output_compute_analysis_mid_co:\n",
    "\n",
    "        display(Markdown(\"<h3>Spectrum distribution</h3>\"))\n",
    "\n",
    "        s0range, taurange, polyadm, s, tau, q, avalue, sysderivatif, alpha, \\\n",
    "            a, sol = compute_admissibilite(\n",
    "                n, m, a_coeff_mid_co)\n",
    "\n",
    "        finaleq = sysderivatif[-1].subs(\n",
    "            {alph: alphacoef for alph, alphacoef in zip(alpha, sol)})\n",
    "        finaleq = finaleq.subs({asymb: aval for asymb, aval in zip(a, avalue)})\n",
    "\n",
    "        if user_choice == 'tau':\n",
    "\n",
    "            value_tau = user_value\n",
    "            sols0 = finaleq.subs({tau: value_tau})\n",
    "            sols0 = sp.solve(sols0)\n",
    "            computeds0 = sols0[1]\n",
    "            alpha_num = sol.subs(\n",
    "                {asymb: aval for asymb, aval in zip(a, avalue)})\n",
    "            alpha_num = alpha_num.subs({s: computeds0})\n",
    "            alpha_num = alpha_num.subs({tau: value_tau})\n",
    "            alpha_num_eval = [i.evalf() for i in alpha_num]\n",
    "            b_coeff_mid_co = alpha_num_eval.copy()\n",
    "            xr, yr, eq = compute_root_spectrum_mid_co(n, m, value_tau)\n",
    "\n",
    "        elif user_choice == 's0':\n",
    "\n",
    "            value_s0 = user_value\n",
    "            soltau = finaleq.subs({s: value_s0})\n",
    "            soltau = sp.solve(soltau)\n",
    "            computedtau = soltau[0]\n",
    "            alpha_num = sol.subs(\n",
    "                {asymb: aval for asymb, aval in zip(a, avalue)})\n",
    "            alpha_num = alpha_num.subs({tau: computedtau})\n",
    "            alpha_num = alpha_num.subs({s: value_s0})\n",
    "            alpha_num_eval = [i.evalf() for i in alpha_num]\n",
    "            b_coeff_mid_co = alpha_num_eval.copy()\n",
    "            xr, yr, eq = compute_root_spectrum_mid_co(n, m, computedtau)\n",
    "\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        ax.set_title(\"Spectrum distribution\")\n",
    "        ax.set_xlabel(r\"$\\Re(s)$\")\n",
    "        ax.set_ylabel(r\"$\\Im(s)$\")\n",
    "        ax.axhline(linewidth=2, color='black', zorder=2)\n",
    "        ax.axvline(linewidth=2, color='black', zorder=2)\n",
    "        ax.axvspan(0, 100, alpha=0.5, color='red', zorder=2,\n",
    "                   label='Unstable system')\n",
    "        ax.grid()\n",
    "        line, = ax.plot([], [], 'o', color='steelblue', zorder=3,\n",
    "                        label='Roots')\n",
    "        xmax = max(xr)\n",
    "        plt.xlim([-10, 1])\n",
    "        line.set_data(xr, yr)\n",
    "        xmax_round = round(xmax, 2)\n",
    "        line2, = ax.plot([], [], '*', markersize=20, color='#ff9900', zorder=3,\n",
    "                         label='Rightmost root (' + str(\n",
    "                             xmax_round) + ';' + '0' + ')')\n",
    "        line2.set_data(xmax, 0)\n",
    "        ax.legend(loc='upper right')\n",
    "        ax.relim()\n",
    "        fig.canvas.draw()\n",
    "\n",
    "        display(Markdown(\"<h3>Parameters</h3>\"))\n",
    "\n",
    "        if user_choice == 'tau':\n",
    "            print(\"n = \", slider_n_mid_co.value, \", m = \",\n",
    "                  slider_m_mid_co.value, \", s0 = \", computeds0, \", tau = \",\n",
    "                  user_value)\n",
    "        elif user_choice == 's0':\n",
    "            print(\"n = \", slider_n_mid_co.value, \", m = \",\n",
    "                  slider_m_mid_co.value, \", s0 = \", user_value, \", tau = \",\n",
    "                  computedtau)\n",
    "\n",
    "        a_coeff_chain = \"\"\n",
    "        b_coeff_chain = \"\"\n",
    "        i = 0\n",
    "        for a_coeff in a_coeff_mid_co:\n",
    "            a_coeff_chain = a_coeff_chain + \"a\" + str(i) + \" = \" + str(\n",
    "                a_coeff) + \", \"\n",
    "            i = i + 1\n",
    "        print(a_coeff_chain)\n",
    "        i = 0\n",
    "        for b_coeff in b_coeff_mid_co:\n",
    "            b_coeff_chain = b_coeff_chain + \"b\" + str(i) + \" = \" + str(\n",
    "                b_coeff) + \", \"\n",
    "            i = i + 1\n",
    "        print(b_coeff_chain)\n",
    "\n",
    "        display(Markdown(\"<h3>Ouput equation</h3>\"))\n",
    "        print(\"Fp = \", eq)\n",
    "\n",
    "\n",
    "def computation_3_mid_co(n, m, user_choice, user_value):\n",
    "    output_sensibilite_computation_mid_co.clear_output()\n",
    "\n",
    "    global a_coeff_mid_co\n",
    "    global b_coeff_mid_co\n",
    "    global computedtau\n",
    "\n",
    "    with output_sensibilite_computation_mid_co:\n",
    "\n",
    "        s0range, taurange, polyadm, s, tau, q, avalue, sysderivatif, alpha, \\\n",
    "            a, sol = compute_admissibilite(n, m, a_coeff_mid_co)\n",
    "\n",
    "        if user_choice == 'tau':\n",
    "\n",
    "            value_tau = user_value\n",
    "\n",
    "        elif user_choice == 's0':\n",
    "\n",
    "            if type(computedtau).__name__ == \"Add\":\n",
    "                value_tau = computedtau.as_real_imag()[0].evalf(10)\n",
    "            elif type(computedtau).__name__ == \"Float\":\n",
    "                value_tau = float(computedtau.evalf(10))\n",
    "            value_tau = round(value_tau, 5)\n",
    "\n",
    "        tau_sens, s0_sens, colormapper = compute_sensibilite(value_tau, q, m,\n",
    "                                                             s, sysderivatif,\n",
    "                                                             alpha, a, tau)\n",
    "\n",
    "        display(Markdown(\"<h3>Sensitivity plot</h3>\"))\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        alpha_sens = b_coeff_mid_co.copy()\n",
    "        for i in range(len(tau_sens)):\n",
    "            xroot, yroot, func = getroots(1, q, tau_sens[i], avalue,\n",
    "                                          alpha_sens, [-5, 5], [-5, 5], s, a,\n",
    "                                          alpha, tau)\n",
    "            ax.scatter(xroot, yroot, c=len(xroot) * [\n",
    "                colormapper.to_rgba(float(tau_sens[i]))])\n",
    "\n",
    "        ax.grid()\n",
    "        ax.set_axisbelow(True)\n",
    "        fig.colorbar(colormapper)\n",
    "\n",
    "        ax.set_xlabel(r\"$Re(s)$\")\n",
    "        ax.set_ylabel(r\"$Im(s)$\")\n",
    "        ax.set_title(\n",
    "            r\"Sensitivity plot, $\\tau \\in $\" +\n",
    "            f\"[{tau_sens[0]}, {tau_sens[-1]}]\")\n",
    "        tau_sens.sort()\n",
    "\n",
    "\n",
    "def computation_4_mid_co(degn, delay, acoef, bcoef, t_final, n_iter, init_type,\n",
    "                         init_args):\n",
    "    output_time_simulation_computation_mid_co.clear_output()\n",
    "\n",
    "    with output_time_simulation_computation_mid_co:\n",
    "        display(Markdown(\"<h3>Time simulation plot</h3>\"))\n",
    "        time_initsolution, sol_initsolution = initialsolution(degn, delay,\n",
    "                                                              acoef, bcoef,\n",
    "                                                              t_final, n_iter,\n",
    "                                                              init_type,\n",
    "                                                              init_args)\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        plt.plot(time_initsolution, sol_initsolution[0, :], '#f84434')\n",
    "        ax.grid()\n",
    "        plt.xlabel(r\"$t$ (in second)\", fontsize=12)\n",
    "        plt.ylabel(r\"$y(t)$\")\n",
    "        plt.title(\"Time simulation\")\n",
    "\n",
    "\n",
    "def button_confirm_system_coeff_clicked_mid_co(self):\n",
    "    global a_coeff_mid_co\n",
    "\n",
    "    n_mid_co = slider_n_mid_co.value\n",
    "    m_mid_co = slider_m_mid_co.value\n",
    "    a_coeff_mid_co = []\n",
    "\n",
    "    for i in range(slider_n_mid_co.value):\n",
    "        a_coeff_mid_co.append(items_inttext_a_mid_co[i].value)\n",
    "\n",
    "    computation_1_mid_co(n_mid_co, m_mid_co, a_coeff_mid_co)\n",
    "\n",
    "\n",
    "def button_confirm_degrees_clicked_mid_co(self):\n",
    "    for k in range(len(items_inttext_a_mid_co)):\n",
    "        items_inttext_a_mid_co[k].value = 0\n",
    "        items_inttext_a_mid_co[k].disabled = True\n",
    "        items_inttext_a_mid_co[k].description = ''\n",
    "\n",
    "    for i in range(slider_n_mid_co.value):\n",
    "        items_inttext_a_mid_co[i].value = 1\n",
    "        items_inttext_a_mid_co[i].disabled = False\n",
    "        items_inttext_a_mid_co[i].description = \"a\" + str(i)\n",
    "\n",
    "    items_inttext_a_mid_co[slider_n_mid_co.value].value = 1\n",
    "    items_inttext_a_mid_co[slider_n_mid_co.value].disabled = True\n",
    "    items_inttext_a_mid_co[slider_n_mid_co.value].description = \"a\" + str(\n",
    "        slider_n_mid_co.value)\n",
    "\n",
    "\n",
    "def button_ready_to_compute_clicked_mid_co(self):\n",
    "    global a_coeff_mid_co\n",
    "\n",
    "    n_mid_co = slider_n_mid_co.value\n",
    "    m_mid_co = slider_m_mid_co.value\n",
    "    user_choice = togglebuttons_mid_co.value\n",
    "    user_value = floattext_s0_tau_mid_co.value\n",
    "\n",
    "    computation_2_mid_co(n_mid_co, m_mid_co, user_choice, user_value)\n",
    "\n",
    "\n",
    "def button_ready_to_sensitivity_clicked_mid_co(self):\n",
    "    n_mid_co = slider_n_mid_co.value\n",
    "    m_mid_co = slider_m_mid_co.value\n",
    "\n",
    "    user_choice = togglebuttons_mid_co.value\n",
    "\n",
    "    user_value = floattext_s0_tau_mid_co.value\n",
    "\n",
    "    computation_3_mid_co(n_mid_co, m_mid_co, user_choice, user_value)\n",
    "\n",
    "\n",
    "def button_ready_to_simulation_time_clicked_mid_co(self):\n",
    "    degn = slider_n_mid_co.value\n",
    "\n",
    "    if togglebuttons_mid_co.value == 's0':\n",
    "        delay = computedtau\n",
    "\n",
    "    elif togglebuttons_mid_co.value == 'tau':\n",
    "        delay = floattext_s0_tau_mid_co.value\n",
    "\n",
    "    acoef = a_coeff_mid_co\n",
    "    bcoef = b_coeff_mid_co\n",
    "    t_final = floattext_simulation_time_mid_co.value\n",
    "    n_iter = 100000\n",
    "    init_type = dropdown_mid_co.value\n",
    "\n",
    "    if init_type == 'Constant':\n",
    "        init_args = [constant_constant_mid_co.value]\n",
    "\n",
    "    elif init_type == 'Polynomial':\n",
    "        init_args = [int(polynomial_degree_mid_co.value)]\n",
    "\n",
    "        for i in range(int(polynomial_degree_mid_co.value) + 1):\n",
    "            init_args.append(items_floattext_polynomial_coef_mid_co[i].value)\n",
    "\n",
    "    elif init_type == 'Exponential':\n",
    "        init_args = [exponential_gain_mid_co.value,\n",
    "                     exponential_exponant_mid_co.value]\n",
    "\n",
    "    elif init_type == 'Trigonometric':\n",
    "        init_args = [trigonometric_amplitude_mid_co.value,\n",
    "                     trigonometric_frequency_mid_co.value,\n",
    "                     trigonometric_phase_mid_co.value]\n",
    "\n",
    "    computation_4_mid_co(degn, delay, acoef, bcoef, t_final, n_iter, init_type,\n",
    "                         init_args)\n",
    "\n",
    "\n",
    "button_ready_to_simulation_time_mid_co.on_click(\n",
    "    button_ready_to_simulation_time_clicked_mid_co)\n",
    "\n",
    "button_ready_to_compute_mid_co.on_click(button_ready_to_compute_clicked_mid_co)\n",
    "\n",
    "button_ready_to_sensitivity_mid_co.on_click(\n",
    "    button_ready_to_sensitivity_clicked_mid_co)\n",
    "\n",
    "button_confirm_degrees_mid_co.on_click(button_confirm_degrees_clicked_mid_co)\n",
    "\n",
    "button_confirm_system_coeff_mid_co.on_click(\n",
    "    button_confirm_system_coeff_clicked_mid_co)\n",
    "\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "def computation_1_crrid_generic(n, m, s0, d, value_tau):\n",
    "    output_compute_analysis_mid_crrid_generic.clear_output()\n",
    "\n",
    "    with output_compute_analysis_mid_crrid_generic:\n",
    "\n",
    "        display(Markdown(\"<h3>Spectrum distribution</h3>\"))\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        ax.set_title(\"Spectrum distribution with equidistributed rightmost \"\n",
    "                     \"spectral values\")\n",
    "        ax.set_xlabel(r\"Re$(s)$\")\n",
    "        ax.set_ylabel(r\"Im$(s)$\")\n",
    "        ax.axhline(linewidth=2, color='black', zorder=2)\n",
    "        ax.axvline(linewidth=2, color='black', zorder=2)\n",
    "        ax.axvspan(0, 100, alpha=0.5, color='red', zorder=2,\n",
    "                   label='Unstable system')\n",
    "        ax.grid()\n",
    "        line, = ax.plot([], [], 'o', color='steelblue', zorder=3,\n",
    "                        label='Roots')\n",
    "        line2, = ax.plot([], [], '*', markersize=15, color='green', zorder=3,\n",
    "                         label='Rightmost root')\n",
    "        xr, yr, eq = compute_crrid_generic_root(n, m, s0, d, value_tau)\n",
    "        plt.xlim([-10, 1])\n",
    "        line.set_data(xr, yr)\n",
    "        xmax2 = max(xr)\n",
    "        line2.set_data(xmax2, 0)\n",
    "        ax.legend(loc='upper right')\n",
    "        ax.relim()\n",
    "        fig.canvas.draw()\n",
    "\n",
    "        display(Markdown(\"<h3>Parameters</h3>\"))\n",
    "        print(\"n = \", slider_n_crrid_generic.value, \", m = \",\n",
    "              slider_m_crrid_generic.value, \", s0 = \",\n",
    "              floattext_s0_crrid_generic.value, \", tau = \",\n",
    "              floattext_tau_crrid_generic.value)\n",
    "        a_coeff_chain = \"\"\n",
    "        b_coeff_chain = \"\"\n",
    "        i = 0\n",
    "        for a_coeff in a_coeff_crrid_generic:\n",
    "            a_coeff_chain = a_coeff_chain + \"a\" + str(i) + \" = \" + str(\n",
    "                a_coeff) + \", \"\n",
    "            i = i + 1\n",
    "        print(a_coeff_chain)\n",
    "        i = 0\n",
    "        for b_coeff in b_coeff_crrid_generic:\n",
    "            b_coeff_chain = b_coeff_chain + \"b\" + str(i) + \" = \" + str(\n",
    "                b_coeff) + \", \"\n",
    "            i = i + 1\n",
    "        print(b_coeff_chain)\n",
    "\n",
    "        display(Markdown(\"<h3>Ouput equation</h3>\"))\n",
    "        print(\"Fp = \", eq)\n",
    "\n",
    "\n",
    "def button_ready_to_compute_clicked_mid_crrid_generic(self):\n",
    "    n_crrid_generic = slider_n_crrid_generic.value\n",
    "    m_crrid_generic = slider_m_crrid_generic.value\n",
    "    s0_crrid_generic = floattext_s0_crrid_generic.value\n",
    "    d_crrid_generic = slider_d_crrid_generic.value\n",
    "    tau_crrid_generic = floattext_tau_crrid_generic.value\n",
    "\n",
    "    computation_1_crrid_generic(n_crrid_generic, m_crrid_generic,\n",
    "                                s0_crrid_generic, d_crrid_generic,\n",
    "                                tau_crrid_generic)\n",
    "\n",
    "\n",
    "button_ready_to_compute_mid_crrid_generic.on_click(\n",
    "    button_ready_to_compute_clicked_mid_crrid_generic)\n",
    "\n",
    "\n",
    "def computation_2_crrid_generic(degn, delay, acoef, bcoef, t_final, n_iter,\n",
    "                                init_type, init_args):\n",
    "    output_time_simulation_computation_1_crrid_generic.clear_output()\n",
    "\n",
    "    with output_time_simulation_computation_1_crrid_generic:\n",
    "        display(Markdown(\"<h3>Time simulation plot</h3>\"))\n",
    "        time_initsolution, sol_initsolution = initialsolution(degn, delay,\n",
    "                                                              acoef, bcoef,\n",
    "                                                              t_final, n_iter,\n",
    "                                                              init_type,\n",
    "                                                              init_args)\n",
    "        fig, ax = plt.subplots(figsize=(9, 5))\n",
    "        plt.plot(time_initsolution, sol_initsolution[0, :], '#f84434')\n",
    "        ax.grid()\n",
    "        plt.xlabel(r\"$t$ (in second)\", fontsize=12)\n",
    "        plt.ylabel(r\"$y(t)$\")\n",
    "        plt.title(\"Time simulation\")\n",
    "\n",
    "\n",
    "def button_ready_to_simulation_time_clicked_crrid_generic(self):\n",
    "    degn = slider_n_crrid_generic.value\n",
    "    delay = floattext_tau_crrid_generic.value\n",
    "    acoef = a_coeff_crrid_generic\n",
    "    bcoef = b_coeff_crrid_generic\n",
    "    t_final = floattext_simulation_time_crrid_generic.value\n",
    "    n_iter = 100000\n",
    "    init_type = dropdown_crrid_generic.value\n",
    "\n",
    "    if init_type == 'Constant':\n",
    "        init_args = [constant_constant_crrid_generic.value]\n",
    "\n",
    "    elif init_type == 'Polynomial':\n",
    "        init_args = [int(polynomial_degree_crrid_generic.value)]\n",
    "\n",
    "        for i in range(int(polynomial_degree_crrid_generic.value) + 1):\n",
    "            init_args.append(\n",
    "                items_floattext_polynomial_coef_crrid_generic[i].value)\n",
    "\n",
    "    elif init_type == 'Exponential':\n",
    "        init_args = [exponential_gain_crrid_generic.value,\n",
    "                     exponential_exponant_crrid_generic.value]\n",
    "\n",
    "    elif init_type == 'Trigonometric':\n",
    "        init_args = [trigonometric_amplitude_crrid_generic.value,\n",
    "                     trigonometric_frequency_crrid_generic.value,\n",
    "                     trigonometric_phase_crrid_generic.value]\n",
    "\n",
    "    computation_2_crrid_generic(degn, delay, acoef, bcoef, t_final, n_iter,\n",
    "                                init_type, init_args)\n",
    "\n",
    "\n",
    "button_ready_to_simulation_time_crrid_generic.on_click(\n",
    "    button_ready_to_simulation_time_clicked_crrid_generic)\n",
    "\n",
    "# -----------------------------------------------------------------------------\n",
    "# User Interface output\n",
    "# -----------------------------------------------------------------------------\n",
    "\n",
    "title_analysis = widgets.HTML(\n",
    "    \"<h2 class = 'text-center'><font color='#ff9c28'>\"\n",
    "    \"Analysis</font><size='10'>\")\n",
    "title_time_simulation = widgets.HTML(\n",
    "    \"<h2 class = 'text-center'><font color='#f84434'>\"\n",
    "    \"Time simulation</font><size='10'>\")\n",
    "title_sensitivity = widgets.HTML(\n",
    "    \"<h2 class = 'text-center'><font color='#10acd8'>\"\n",
    "    \"Sensitivity</font><size='10'>\")\n",
    "\n",
    "description_label_mid_generic = widgets.Label(\n",
    "    'Insert degree of polynomial n, degree of delay polynomial m, rightmost '\n",
    "    'root s0 and delay tau, then push the button to compute : ')\n",
    "separator_label = widgets.Label(\n",
    "    '_________________________________________________________________________'\n",
    "    '___________________________________________________________')\n",
    "time_simulation_label = widgets.Label(\n",
    "    'Choose initial condition and insert time simulation t :')\n",
    "\n",
    "description_label_mid_co = widgets.Label(\n",
    "    'Insert degree of polynomial n and degree of delay polynomial m, '\n",
    "    'then push the button to confirm : ')\n",
    "description_label_2_mid_co = widgets.Label(\n",
    "    'Insert values of system coefficients, then push the button to confirm '\n",
    "    'and draw the admissibility plot : ')\n",
    "description_label_3_mid_co = widgets.Label(\n",
    "    'Select between rightmost root s0 or delay tau using the admissibility '\n",
    "    'plot, then push the button to compute : ')\n",
    "description_label_crrid_generic = widgets.VBox([widgets.Label(\n",
    "    'Insert degree of polynomial n, degree of delay polynomial m, rightmost '\n",
    "    'root s0, step d between each value of s0 and delay tau, then push the '\n",
    "    'button to compute :')],\n",
    "    layout=widgets.Layout(\n",
    "        width='100%',\n",
    "        display='flex',\n",
    "        align_items='center'))\n",
    "\n",
    "box_input_mid_generic = widgets.HBox(\n",
    "    [slider_n_mid_generic, slider_m_mid_generic, floatext_s0_mid_generic,\n",
    "     floattext_tau_mid_generic])\n",
    "box_input_mid_co = widgets.HBox(\n",
    "    [slider_n_mid_co, slider_m_mid_co, button_confirm_degrees_mid_co])\n",
    "box_input_2_mid_co = widgets.HBox([inttext_a_1_mid_co],\n",
    "                                  layout=widgets.Layout(width='auto'))\n",
    "box_input_3_mid_co = widgets.HBox(\n",
    "    [inttext_a_2_mid_co, button_confirm_system_coeff_mid_co],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "box_input_4_mid_co = widgets.HBox(\n",
    "    [togglebuttons_mid_co, floattext_s0_tau_mid_co],\n",
    "    layout=widgets.Layout(width='auto'))\n",
    "box_input_1_crrid_generic = widgets.HBox(\n",
    "    [slider_n_crrid_generic, slider_m_crrid_generic, slider_d_crrid_generic])\n",
    "box_input_2_crrid_generic = widgets.HBox(\n",
    "    [floattext_s0_crrid_generic, floattext_tau_crrid_generic])\n",
    "\n",
    "accordion_1_mid_generic = widgets.Accordion(\n",
    "    children=[output_compute_analysis_mid_generic],\n",
    "    titles=('Output analysis', ''))\n",
    "accordion_2_mid_generic = widgets.Accordion(\n",
    "    children=[output_time_simulation_computation_mid_generic],\n",
    "    titles=('Output time simulation', ''))\n",
    "accordion_1_mid_generic.selected_index = 0\n",
    "accordion_2_mid_generic.selected_index = 0\n",
    "\n",
    "accordion_1_mid_co = widgets.Accordion(\n",
    "    children=[output_admissibilite_computation_mid_co],\n",
    "    titles=('Output admissibility', ''))\n",
    "accordion_1_mid_co.selected_index = 0\n",
    "accordion_2_mid_co = widgets.Accordion(\n",
    "    children=[output_compute_analysis_mid_co], titles=('Output analysis', ''))\n",
    "accordion_2_mid_co.selected_index = 0\n",
    "accordion_3_mid_co = widgets.Accordion(\n",
    "    children=[output_sensibilite_computation_mid_co],\n",
    "    titles=('Output sensitivity', ''))\n",
    "accordion_3_mid_co.selected_index = 0\n",
    "accordion_4_mid_co = widgets.Accordion(\n",
    "    children=[output_time_simulation_computation_mid_co],\n",
    "    titles=('Output time simulation', ''))\n",
    "accordion_4_mid_co.selected_index = 0\n",
    "\n",
    "accordion_1_crrid_generic = widgets.Accordion(\n",
    "    children=[output_compute_analysis_mid_crrid_generic],\n",
    "    titles=('Output analysis', ''))\n",
    "accordion_1_crrid_generic.selected_index = 0\n",
    "accordion_2_crrid_generic = widgets.Accordion(\n",
    "    children=[output_time_simulation_computation_1_crrid_generic],\n",
    "    titles=('Output time simulation', ''))\n",
    "accordion_2_crrid_generic.selected_index = 0\n",
    "\n",
    "box_mid_generic = widgets.VBox(\n",
    "    [text_error_mid_generic, title_analysis, description_label_mid_generic,\n",
    "     box_input_mid_generic, layout_validate_1_mid_generic,\n",
    "     accordion_1_mid_generic, separator_label, title_time_simulation,\n",
    "     time_simulation_label, stacked_simulation_time_mid_generic,\n",
    "     floattext_simulation_time_mid_generic, layout_validate_2_mid_generic,\n",
    "     accordion_2_mid_generic])\n",
    "box_mid_co = widgets.VBox(\n",
    "    [text_error_mid_co, title_analysis, description_label_mid_co,\n",
    "     box_input_mid_co, description_label_2_mid_co, box_input_2_mid_co,\n",
    "     box_input_3_mid_co, accordion_1_mid_co, description_label_3_mid_co,\n",
    "     box_input_4_mid_co, layout_validate_1_mid_co, accordion_2_mid_co,\n",
    "     separator_label, title_sensitivity, layout_validate_3_mid_co,\n",
    "     accordion_3_mid_co, separator_label, title_time_simulation,\n",
    "     time_simulation_label, stacked_simulation_time_mid_co,\n",
    "     floattext_simulation_time_mid_co, layout_validate_2_mid_co,\n",
    "     accordion_4_mid_co])\n",
    "box_crrid_generic = widgets.VBox(\n",
    "    [text_error_crrid_generic, title_analysis, description_label_crrid_generic,\n",
    "     box_input_1_crrid_generic, box_input_2_crrid_generic,\n",
    "     layout_validate_1_mid_crrid_generic, accordion_1_crrid_generic,\n",
    "     separator_label, title_time_simulation, time_simulation_label,\n",
    "     stacked_simulation_time_crrid_generic,\n",
    "     floattext_simulation_time_crrid_generic, layout_validate_2_crrid_generic,\n",
    "     accordion_2_crrid_generic])\n",
    "\n",
    "tab = widgets.Tab()\n",
    "tab.children = [box_mid_generic, box_mid_co, box_crrid_generic]\n",
    "tab.titles = ('MID Generic', 'MID Control oriented', 'CRRID Generic')\n",
    "\n",
    "file = open(\"images/header_p3d_online.png\", \"rb\")\n",
    "image = file.read()\n",
    "header_image = widgets.Image(value=image, format='png', width=975, height=25)\n",
    "\n",
    "dashboard = widgets.VBox([header_image, tab])\n",
    "display(dashboard)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Format de la Cellule Texte Brut",
  "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}