Tesis2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5619fcb8",
   "metadata": {
    "hide_input": false,
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "outputs": [],
   "source": [
    "# Librerias\n",
    "import ipywidgets as ipw\n",
    "import bqplot as bqp\n",
    "import numpy as np\n",
    "import sympy as sp\n",
    "import ipysheet as ips\n",
    "from bqplot import pyplot as plt\n",
    "from scipy import interpolate as numint\n",
    "from sympy.printing import latex\n",
    "from sympy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "861314c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<center><font face=\"Times New Roman\"><font size=\"10\">\n",
       "    Calculo de ejes de transmicion de potencia\n",
       "</font></font></center>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%HTML\n",
    "<center><font face=\"Times New Roman\"><font size=\"10\">\n",
    "    Calculo de ejes de transmicion de potencia\n",
    "</font></font></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4a006ce6",
   "metadata": {
    "cell_style": "center",
    "scrolled": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<div style=\"font-family: 'Times New Roman';\">\n",
       "\n",
       "    <div style=\"display: inline-block;  width: 49%;\">\n",
       "<b>Ecuaciones Analiticas: Euler - Bernoulli</b><br><br>\n",
       "Realiza el calculo para todo el dominio del eje, es decir, que se puede determinar el valor deseado \n",
       "para cualquier punto del eje de manera exacta. Debido a ello, es que toma mas tiempo en comparacion con el metodo \n",
       "de los elementos finitos. Finalmente, este metodo no considera los desplazamientos por cizalladura al estar desarrollado \n",
       "bajo la teoria de Euler-Bernoulli.\n",
       "<img src=\"https://drive.google.com/uc?export=view&id=17dlMj4lBNnD5-w4cKj9Z0hM_tngVgap8\">\n",
       "    </div>\n",
       "\n",
       "    <div style=\"display: inline-block;  width: 49%;\">\n",
       "<b>Elementos Finitos: Timoshenko</b><br><br>\n",
       "Este metodo realiza el calculo para ciertos puntos del eje, por lo que para determinar el valor desaeado en algun punto\n",
       "del eje, se debera interpolar. Debido a ello, es que toma menos tiempo en comparacion con las ecuaciones analiticas. \n",
       "Finalmente, este metodo si considera los desplazamientos por cizalladura al estar desarrollado \n",
       "bajo la teoria de Timoshenko.\n",
       "<img src=\"https://drive.google.com/uc?export=view&id=19L6nlcfpY6rx_ymF9DxHFR_2K0p8a_Z1\">\n",
       "    </div>\n",
       "    \n",
       "</div>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "\n",
    "<div style=\"font-family: 'Times New Roman';\">\n",
    "\n",
    "    <div style=\"display: inline-block;  width: 49%;\">\n",
    "<b>Ecuaciones Analiticas: Euler - Bernoulli</b><br><br>\n",
    "Realiza el calculo para todo el dominio del eje, es decir, que se puede determinar el valor deseado \n",
    "para cualquier punto del eje de manera exacta. Debido a ello, es que toma mas tiempo en comparacion con el metodo \n",
    "de los elementos finitos. Finalmente, este metodo no considera los desplazamientos por cizalladura al estar desarrollado \n",
    "bajo la teoria de Euler-Bernoulli.\n",
    "<img src=\"https://drive.google.com/uc?export=view&id=17dlMj4lBNnD5-w4cKj9Z0hM_tngVgap8\">\n",
    "    </div>\n",
    "\n",
    "    <div style=\"display: inline-block;  width: 49%;\">\n",
    "<b>Elementos Finitos: Timoshenko</b><br><br>\n",
    "Este metodo realiza el calculo para ciertos puntos del eje, por lo que para determinar el valor desaeado en algun punto\n",
    "del eje, se debera interpolar. Debido a ello, es que toma menos tiempo en comparacion con las ecuaciones analiticas. \n",
    "Finalmente, este metodo si considera los desplazamientos por cizalladura al estar desarrollado \n",
    "bajo la teoria de Timoshenko.\n",
    "<img src=\"https://drive.google.com/uc?export=view&id=19L6nlcfpY6rx_ymF9DxHFR_2K0p8a_Z1\">\n",
    "    </div>\n",
    "    \n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "12c88b92",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "86e29b796ca247ccb3c74acef6b1a188",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(HTML(value='<center><font face=\"Times New Roman\"><font size=\"5\">                …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "margin1 = '0px 0px 10px 0px'\n",
    "width1  = '225px'\n",
    "HTML3 = ipw.HTML(\n",
    "        value  = f'<center><font face=\"Times New Roman\"><font size=\"5\">\\\n",
    "                 Parametros de calculo\\\n",
    "                 </font></font></center>',\n",
    "        layout = ipw.Layout(width = '250px', margin = margin1)\n",
    ") \n",
    "Dropdown1 = ipw.Dropdown(\n",
    "            options = ['Elastico', 'Fijo'],\n",
    "            value = 'Elastico',\n",
    "            description = 'Apoyo 1',\n",
    "            layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "Dropdown2 = ipw.Dropdown(\n",
    "            options = ['Elastico', 'Fijo'],\n",
    "            value = 'Fijo',\n",
    "            description = 'Apoyo 2',\n",
    "            layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "Dropdown3 = ipw.Dropdown(\n",
    "            options = ['Cortantes', 'Momentos', 'Pendientes', 'Deflexiones'],\n",
    "            value = 'Cortantes',\n",
    "            description = 'Grafica de: ',\n",
    "            layout = ipw.Layout(width = '30%', height = 'auto', margin = '0px 30px 0px 0px')\n",
    ")\n",
    "BoundedFloatText1 = ipw.BoundedFloatText(\n",
    "                    value = 7850,\n",
    "                    min = 10,\n",
    "                    max = 10000,\n",
    "                    step = 10,\n",
    "                    description = 'D (kg/m3)',\n",
    "                    layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "BoundedFloatText2 = ipw.BoundedFloatText(\n",
    "                    value = 50,\n",
    "                    min = 10,\n",
    "                    max = 10000,\n",
    "                    step = 0.005,\n",
    "                    description = 'Ø ext. (mm)',\n",
    "                    layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "BoundedFloatText3 = ipw.BoundedFloatText(\n",
    "                    value = 25,\n",
    "                    min = 0,\n",
    "                    max = 10000,\n",
    "                    step = 0.005,\n",
    "                    description = 'Ø int. (mm)',\n",
    "                    layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "BoundedFloatText4 = ipw.BoundedFloatText(\n",
    "                    value = 100,\n",
    "                    min = 10,\n",
    "                    max = 10000,\n",
    "                    step = 0.05,\n",
    "                    description = 'L (mm)',\n",
    "                    layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "BoundedFloatText5 = ipw.BoundedIntText(\n",
    "                    value = 10,\n",
    "                    min = 0,\n",
    "                    max = 1000,\n",
    "                    step = 1,\n",
    "                    description = 'Elementos',\n",
    "                    layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "FloatText2 = ipw.FloatText(\n",
    "             description = 'F (KN)',\n",
    "             layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "FloatText3 = ipw.FloatText(\n",
    "             description = 'M (KN.m)',\n",
    "             layout = ipw.Layout(width = width1, margin = margin1)\n",
    ")\n",
    "FloatSlider3 = ipw.FloatSlider(\n",
    "               description = 'X',\n",
    "               min = 0,\n",
    "               max = BoundedFloatText4.value,\n",
    "               value = BoundedFloatText4.value / 2,\n",
    "               layout = ipw.Layout(margin = margin1)\n",
    ")\n",
    "Checkbox1 = ipw.Checkbox(\n",
    "            value = True,\n",
    "            description = 'Peso propio del eje',\n",
    "            layout = ipw.Layout(width = width1, margin = margin1),\n",
    "            indent = True\n",
    ")\n",
    "Button1 = ipw.Button(\n",
    "          description = 'Calcular',\n",
    "          button_style = 'success',\n",
    "          icon = 'fa-gear',\n",
    "          layout = ipw.Layout(width = '20%', height = 'auto', margin = '0px 5px 0px 0px')\n",
    ")\n",
    "Button1.style.button_color = 'black'\n",
    "Button2 = ipw.Button(\n",
    "          description = 'Graficar',\n",
    "          button_style = 'success',\n",
    "          icon = 'fa-pencil',\n",
    "          layout = ipw.Layout(width = '20%', height = 'auto', margin = '0px 35px 0px 0px')\n",
    ")\n",
    "Button2.style.button_color = 'black'\n",
    "Button3 = ipw.Button(\n",
    "          description = 'Enumerar',\n",
    "          button_style = 'success',\n",
    "          icon = 'fa-eye',\n",
    "          layout = ipw.Layout(width = '20%', height = 'auto', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "Button3.style.button_color = 'black'\n",
    "sheet1 = ips.sheet(\n",
    "         rows = 3, \n",
    "         columns = 2, \n",
    "         column_headers = [\"Deflexiones\", \"Velocidad Critica\"], \n",
    "         row_headers = [\"Berno.\", \"Timo.\", \"% Error\"], \n",
    "         column_width = [1, 1],\n",
    "         layout = ipw.Layout(width = 'auto', height = 'auto')\n",
    ")\n",
    "\n",
    "scale_x2 = bqp.LinearScale()\n",
    "scale_y2 = bqp.LinearScale()\n",
    "Lines1 = bqp.Lines(x = [], y = [],\n",
    "         scales = {'x': scale_x2, 'y': scale_y2,},\n",
    "         opacities = [1],\n",
    "         colors = ['black'],\n",
    "         stroke_width = 1.5,\n",
    "         line_style = 'solid'\n",
    ")\n",
    "Lines2 = bqp.Lines(x = [], y = [],\n",
    "         scales = {'x': scale_x2, 'y': scale_y2,},\n",
    "         opacities = [1],\n",
    "         colors = ['black'],\n",
    "         stroke_width = 1.5,\n",
    "         line_style = 'dashed'\n",
    ")\n",
    "scale_x3 = bqp.LinearScale()\n",
    "scale_y3 = bqp.LinearScale()\n",
    "Lines3 = bqp.Lines(x = [], y = [],\n",
    "         scales = {'x': scale_x3, 'y': scale_y3,},\n",
    "         opacities = [1],\n",
    "         colors = ['black'],\n",
    "         stroke_width = 2,\n",
    "         line_style = 'solid',\n",
    "         fill = 'inside',\n",
    "         fill_opacities = [0.3],\n",
    "         close_path = True,\n",
    "         marker = 'circle',\n",
    "         marker_size = 50\n",
    ")\n",
    "scale_x4 = bqp.LinearScale()\n",
    "scale_y4 = bqp.LinearScale()\n",
    "Lines4 = bqp.Lines(x = [], y = [],\n",
    "         scales = {'x': scale_x4, 'y': scale_y4,},\n",
    "         opacities = [1],\n",
    "         colors = ['black'],\n",
    "         stroke_width = 2,\n",
    "         line_style = 'solid',\n",
    "         fill = 'inside',\n",
    "         fill_opacities = [0.3],\n",
    "         close_path = True\n",
    ")\n",
    "Scatter1 = bqp.Scatter(x = [], y = [],\n",
    "                   scales = {'x': scale_x2, 'y': scale_y2,},\n",
    "                   opacities = [1],\n",
    "                   colors = ['black'],\n",
    "                   marker = 'triangle-up',\n",
    "                   default_size = 250\n",
    ")\n",
    "Scatter2 = bqp.Scatter(x = [], y = [],\n",
    "                   scales = {'x': scale_x2, 'y': scale_y2,},\n",
    "                   opacities = [1],\n",
    "                   colors = ['black'],\n",
    "                   marker = 'square',\n",
    "                   default_size = 250\n",
    ")\n",
    "Scatter3 = bqp.Scatter(x = [], y = [],\n",
    "                   scales = {'x': scale_x2, 'y': scale_y2,},\n",
    "                   opacities = [1],\n",
    "                   colors = ['black'],\n",
    "                   marker = 'triangle-down',\n",
    "                   default_size = 100\n",
    ")\n",
    "Scatter4 = bqp.Scatter(x = [], y = [],\n",
    "                   scales = {'x': scale_x4, 'y': scale_y4,},\n",
    "                   opacities = [1],\n",
    "                   colors = ['black'],\n",
    "                   marker = 'circle',\n",
    "                   default_size = 50,\n",
    "                   unhovered_style = {'opacity': 0.5}\n",
    ")\n",
    "\n",
    "ax_x2   = bqp.Axis(scale = scale_x2, label = 'Longitud (mm)', label_color = 'black', label_offset = '-2em', grid_lines = 'none', tick_format = '0.0f', tick_style = {'stroke': 'black'}, color = 'black')\n",
    "ax_y2   = bqp.Axis(scale = scale_y2, label = 'Diametro (mm)', label_color = 'black', label_offset = '-2em', grid_lines = 'none', tick_format = '0.0f', tick_style = {'stroke': 'black'}, color = 'black', orientation = 'vertical')\n",
    "m_fig   = dict(left = 50, top = 20, bottom = 30, right = 30)\n",
    "fig3    = plt.figure(title = 'Esquema del eje a analizar', title_style = {'font-size': '15px','fill': 'black'}, marks = [Lines1, Lines2, Scatter1, Scatter2, Scatter3], axes = [ax_x2, ax_y2], fig_margin = m_fig, layout=ipw.Layout(width = 'auto', height = '65%'))\n",
    "\n",
    "ax_x3   = bqp.Axis(scale = scale_x3, label = 'Longitud (mm)', label_color = 'black', label_offset = '-1em', grid_lines = 'dashed', tick_format = '0.0f', tick_style = {'stroke': 'black'}, color = 'black')\n",
    "ax_y3   = bqp.Axis(scale = scale_y3, label = 'Resultado', label_color = 'black', label_offset = '-1em', grid_lines = 'dashed', tick_format = '0.0f', tick_style = {'stroke': 'black'}, color = 'black', orientation = 'vertical')\n",
    "m_fig   = dict(left = 50, top = 20, bottom = 30, right = 30)\n",
    "fig4    = plt.figure(title = 'Grafica simbolica', title_style = {'font-size': '15px','fill': 'black'}, marks = [Lines3], axes = [ax_x3, ax_y3], fig_margin = m_fig, layout=ipw.Layout(width = 'auto', height = '50%'))\n",
    "\n",
    "ax_x4   = bqp.Axis(scale = scale_x4, label = 'Longitud (mm)', label_color = 'black', label_offset = '-1em', grid_lines = 'dashed', tick_format = '0.0f', tick_style = {'stroke': 'black'}, color = 'black')\n",
    "ax_y4   = bqp.Axis(scale = scale_y4, label = 'Resultado', label_color = 'black', label_offset = '-1em', grid_lines = 'dashed', tick_format = '0.0f', tick_style = {'stroke': 'black'}, color = 'black', orientation = 'vertical')\n",
    "m_fig   = dict(left = 50, top = 20, bottom = 30, right = 30)\n",
    "fig5    = plt.figure(title = 'Grafica numerica', title_style = {'font-size': '15px','fill': 'black'}, marks = [Lines4, Scatter4], axes = [ax_x4, ax_y4], fig_margin = m_fig, layout=ipw.Layout(width = 'auto', height = '50%'))\n",
    "\n",
    "HBox3 = ipw.HBox([Button1, Dropdown3, Button2, Button3], \n",
    "        layout = ipw.Layout(justify_content = 'space-between', width = 'auto', height = 'auto', margin = '0px', padding = '0px', border = '0px'))\n",
    "VBox4 = ipw.VBox([HBox3, fig3, sheet1], \n",
    "        layout = ipw.Layout(justify_content = 'space-around', width = '75%', height = 'auto', margin = '0px', padding = '0px', border = '0px'))\n",
    "VBox2 = ipw.VBox([HTML3, BoundedFloatText1, BoundedFloatText2, BoundedFloatText3, BoundedFloatText4, FloatText2, FloatText3, Dropdown1, Dropdown2, BoundedFloatText5, Checkbox1, FloatSlider3], \n",
    "        layout = ipw.Layout(justify_content = 'flex-start', width = '35%', height = 'auto', margin = '0px', padding = '0px', border = '0px'))\n",
    "HBox2 = ipw.HBox([VBox2, VBox4])\n",
    "display(HBox2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ac611c67",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "49d260a6e1a44c2480671d6bfdcac434",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTMLMath(value=\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Ecuacion …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "HTMLMath16 = ipw.HTMLMath(\n",
    "    layout = ipw.Layout(width = '15%', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "HTMLMath17 = ipw.HTMLMath(\n",
    "    layout = ipw.Layout(width = '15%', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "HTMLMath18 = ipw.HTMLMath(\n",
    "    layout = ipw.Layout(width = '15%', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "HTMLMath19 = ipw.HTMLMath(\n",
    "    layout = ipw.Layout(width = '15%', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "HTMLMath20 = ipw.HTMLMath(\n",
    "    layout = ipw.Layout(width = '15%', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "HTMLMath21 = ipw.HTMLMath(\n",
    "    layout = ipw.Layout(width = '15%', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "VBox5 = ipw.VBox([ipw.HTMLMath(r\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Ecuacion de momentos del 1 tramo:\"), HTMLMath16, \n",
    "                  ipw.HTMLMath(r\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Ecuacion de deflexiones del 1 tramo:\"), HTMLMath17, \n",
    "                  ipw.HTMLMath(r\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Sistema de ecuaciones:\"), HTMLMath18, \n",
    "                  ipw.HTMLMath(r\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Resultados:\"), HTMLMath19, \n",
    "                  ipw.HTMLMath(r\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Ecuacion de deflexiones del 1 tramo:\"), HTMLMath20, \n",
    "                  ipw.HTMLMath(r\"<font size = '3', font color = 'black', font face = 'Times New Roman'>Ecuacion de momentos del 1 tramo:\"), HTMLMath21], \n",
    "                  layout = ipw.Layout(justify_content = 'space-around', width = '100%', height = '400px', margin = '0px', padding = '0px', border = '0px'))\n",
    "display(VBox5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "9c78df38",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3101e6fc8b454c5bbad78a5b97adc5c4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(Output(layout=Layout(height='auto', width='100%')), HTMLMath(value=\"<font size = '10'>x\", layou…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "HTMLMath22 = ipw.HTMLMath()\n",
    "Output1 = ipw.Output(\n",
    "          layout = ipw.Layout(width = '100%', height = 'auto')\n",
    ")\n",
    "with Output1:\n",
    "    display(HTMLMath22)\n",
    "HTMLMath23 = ipw.HTMLMath(\n",
    "             layout = ipw.Layout(width = '15%', height = 'auto')\n",
    ")\n",
    "HTMLMath24 = ipw.HTMLMath(\n",
    "             layout = ipw.Layout(width = '15%', height = 'auto')\n",
    ")\n",
    "HTMLMath25 = ipw.HTMLMath(\n",
    "             value = r\"<font size = '10'>x\",\n",
    "             layout = ipw.Layout(width = '5%', height = 'auto')\n",
    ")\n",
    "HTMLMath26 = ipw.HTMLMath(\n",
    "             value = r\"<font size = '10'>=\",\n",
    "             layout = ipw.Layout(width = '5%', height = 'auto')\n",
    ")\n",
    "HBox4 = ipw.HBox([Output1, HTMLMath25, HTMLMath23, HTMLMath26, HTMLMath24], \n",
    "        layout = ipw.Layout(justify_content = 'space-between', align_items = 'center', width = '100%', height = 'auto', margin = '0px', padding = '0px', border = '0px'))\n",
    "display(HBox4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "de0c173b",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3b38fa623add4578aa98b72e71232f19",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(Figure(axes=[Axis(color='black', grid_lines='dashed', label='Longitud (mm)', label_color='black…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "VBox3 = ipw.VBox([fig4, fig5], \n",
    "        layout = ipw.Layout(justify_content = 'space-around', width = '100%', height = '100%', margin = '0px', padding = '0px', border = '0px'))\n",
    "display(VBox3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "09270414",
   "metadata": {},
   "outputs": [],
   "source": [
    "def round_expr(expr, num_digits):\n",
    "    return expr.xreplace({n : round(n, num_digits) for n in expr.atoms(Number)})\n",
    "\n",
    "def count_elems(valor):\n",
    "    if 'NDom' in globals():\n",
    "        if Scatter4.names == None:\n",
    "            Scatter4.names = np.arange(1, len(NDom) + 1)\n",
    "Button3.on_click(count_elems)\n",
    "\n",
    "def upd_diamay(valor):\n",
    "    draw_shaft(valor, BoundedFloatText3.value, BoundedFloatText4.value, Dropdown1.value, Dropdown2.value, FloatSlider3.value)\n",
    "f_upd_diamay = ipw.interactive(upd_diamay, valor = BoundedFloatText2)\n",
    "\n",
    "def upd_diamen(valor):\n",
    "    draw_shaft(BoundedFloatText2.value, valor, BoundedFloatText4.value, Dropdown1.value, Dropdown2.value, FloatSlider3.value)\n",
    "f_upd_diamen = ipw.interactive(upd_diamen, valor = BoundedFloatText3)\n",
    "\n",
    "def upd_longit(valor):\n",
    "    draw_shaft(BoundedFloatText2.value, BoundedFloatText3.value, valor, Dropdown1.value, Dropdown2.value, FloatSlider3.value)\n",
    "    FloatSlider3.max = valor\n",
    "f_upd_longit = ipw.interactive(upd_longit, valor = BoundedFloatText4)\n",
    "\n",
    "def upd_lefapo(valor):\n",
    "    draw_shaft(BoundedFloatText2.value, BoundedFloatText3.value, BoundedFloatText4.value, valor, Dropdown2.value, FloatSlider3.value)\n",
    "f_upd_lefapo = ipw.interactive(upd_lefapo, valor = Dropdown1)\n",
    "\n",
    "def upd_rigapo(valor):\n",
    "    draw_shaft(BoundedFloatText2.value, BoundedFloatText3.value, BoundedFloatText4.value, Dropdown1.value, valor, FloatSlider3.value)\n",
    "f_upd_rigapo = ipw.interactive(upd_rigapo, valor = Dropdown2)\n",
    "\n",
    "def move_arrow(valor):\n",
    "    draw_shaft(BoundedFloatText2.value, BoundedFloatText3.value, BoundedFloatText4.value, Dropdown1.value, Dropdown2.value, valor)\n",
    "f_move_arrow = ipw.interactive(move_arrow, valor = FloatSlider3)\n",
    "\n",
    "def draw_shaft(DE, DI, L, AI, AD, FS3):\n",
    "    Lines1.x = np.array([[-L / 2, L / 2, L / 2, -L / 2, -L / 2], [FS3 - L / 2, FS3 - L / 2]], dtype = 'object')\n",
    "    Lines1.y = np.array([[-DE / 2, -DE / 2, DE / 2, DE / 2, -DE / 2], [DE / 2, DE]], dtype = 'object')\n",
    "    Lines2.x = np.array([-L / 2, L / 2, L / 2, -L / 2, -L / 2])\n",
    "    Lines2.y = np.array([-DI / 2, -DI / 2, DI / 2, DI / 2, -DI / 2]) \n",
    "    Scatter1.x = [-L / 2]\n",
    "    Scatter1.y = [-DE / 2]\n",
    "    Scatter2.x = [L / 2]\n",
    "    Scatter2.y = [-DE / 2]\n",
    "    Scatter3.x = [FS3 - L / 2]\n",
    "    Scatter3.y = [DE / 2]\n",
    "    if AI == 'Elastico':\n",
    "        Scatter1.marker = 'triangle-up'\n",
    "    else:\n",
    "        Scatter1.marker = 'square'\n",
    "    if AD == 'Elastico':\n",
    "        Scatter2.marker = 'triangle-up'\n",
    "    else:\n",
    "        Scatter2.marker = 'square'\n",
    "\n",
    "def num_calc(L, E, I, G):\n",
    "    L = L\n",
    "    E = E\n",
    "    I = I\n",
    "    G = G\n",
    "    Nod_Tot = np.concatenate((np.array([0]), np.cumsum(L[0:2])))\n",
    "    Nod_Ini = Nod_Tot[0:2]\n",
    "    Nod_Fin = Nod_Tot[1:3]\n",
    "    A   = (np.pi / 4) * ((BoundedFloatText2.value / 1000) ** 2 - (BoundedFloatText3.value / 1000) ** 2)       \n",
    "    m   = np.repeat(BoundedFloatText3.value / BoundedFloatText2.value, 2)\n",
    "    k   = (6 * (1 + m ** 2) ** 2) / (7 * (1 + m ** 2) ** 2 + 20 * m ** 2)\n",
    "    p   = (12 * E * I) / (k * A * G * L ** 2)\n",
    "    N_E = np.repeat(BoundedFloatText5.value + 1, 2)\n",
    "    L_L = (Nod_Fin - Nod_Ini) / N_E\n",
    "    I_I = np.repeat(I, 2)\n",
    "    P_P = np.repeat(p, 2)\n",
    "    E_E = np.repeat(E, 2)\n",
    "    L1  = [np.zeros((1, N_E[0]))[0], np.zeros((1, N_E[1]))[0]]\n",
    "    I1  = [np.zeros((1, N_E[0]))[0], np.zeros((1, N_E[1]))[0]]\n",
    "    E1  = [np.zeros((1, N_E[0]))[0], np.zeros((1, N_E[1]))[0]]\n",
    "    phi1 = [np.zeros((1, N_E[0]))[0], np.zeros((1, N_E[1]))[0]]\n",
    "    for i in range(2):\n",
    "        L1[i] = np.repeat(L_L[i], N_E[i])\n",
    "        I1[i] = np.repeat(I_I[i], N_E[i])\n",
    "        E1[i] = np.repeat(E_E[i], N_E[i])\n",
    "        phi1[i] = np.repeat(P_P[i], N_E[i])\n",
    "    L1   = np.concatenate((L1[0], L1[1]))\n",
    "    I1   = np.concatenate((I1[0], I1[1]))\n",
    "    E1   = np.concatenate((E1[0], E1[1]))\n",
    "    phi1 = np.concatenate((phi1[0], phi1[1]))\n",
    "    MG   = np.zeros((sum(N_E), 2 * (sum(N_E) + 1), 2 * (sum(N_E) + 1)))\n",
    "    ML   = np.zeros((sum(N_E), 4, 4))\n",
    "    for i in range(sum(N_E)):\n",
    "        ML[i, :, :] = (E1[i] / L1[i] ** 3) * (I1[i] / (1 + phi1[i])) * np.array([\n",
    "                      [12, 6 * L1[i], -12, 6 * L1[i]],\n",
    "                      [6 * L1[i], (4 + phi1[i]) * L1[i] ** 2, -6 * L1[i], (2 - phi1[i]) * L1[i] ** 2],\n",
    "                      [-12, -6 * L1[i], 12, -6 * L1[i]],\n",
    "                      [6 * L1[i], (2 - phi1[i]) * L1[i] ** 2, -6 * L1[i], (4 + phi1[i]) * L1[i] ** 2]])\n",
    "        MG[i, np.array([2 * i, 2 * i + 1, 2 * i + 2, 2 * i + 3])[:,np.newaxis], np.array([2 * i, 2 * i + 1, 2 * i + 2, 2 * i + 3])[np.newaxis,:]] = ML[i, :, :]\n",
    "    MG = np.sum(MG, axis = 0)\n",
    "\n",
    "    FCT = np.arange(0, (3 + 2 * BoundedFloatText5.value) * 2)\n",
    "    FCE = np.array([0, (2 + 2 * BoundedFloatText5.value) * 2])\n",
    "    if Dropdown1.value == 'Fijo':\n",
    "        FCE = np.concatenate((FCE, np.array([1])))\n",
    "    if Dropdown2.value == 'Fijo':\n",
    "        FCE = np.concatenate((FCE, np.array([(2 + 2 * BoundedFloatText5.value) * 2 + 1])))\n",
    "    FCS = np.setdiff1d(FCT, FCE)\n",
    "    MRA = MG[FCS[:,np.newaxis], FCS[np.newaxis,:]]\n",
    "    if Checkbox1.value == True:\n",
    "        FDN = - (((np.pi / 4) * ((BoundedFloatText2.value / 1000) ** 2 - (BoundedFloatText3.value / 1000) ** 2)) * (BoundedFloatText4.value / 1000) * BoundedFloatText1.value * 9.81) / (3 + 2 * BoundedFloatText5.value)\n",
    "    else:\n",
    "        FDN = 0\n",
    "    MFD = np.repeat(FDN, 3 + 2 * BoundedFloatText5.value).reshape((3 + 2 * BoundedFloatText5.value, 1))\n",
    "    MDF = np.zeros((3 + 2 * BoundedFloatText5.value, 1))\n",
    "    MDF[1 + BoundedFloatText5.value] = FloatText2.value * 1000\n",
    "    MDF = MDF + MFD\n",
    "    MDM = np.zeros((3 + 2 * BoundedFloatText5.value, 1))\n",
    "    MDM[1 + BoundedFloatText5.value] = FloatText3.value * 1000\n",
    "    MFM = np.hstack((MDF, MDM)).reshape((len(MFD) * 2, 1))\n",
    "    MRB = MFM[FCS]\n",
    "    MRX = np.linalg.solve(MRA, MRB)\n",
    "    MPD = np.zeros(((3 + 2 * BoundedFloatText5.value) * 2, 1))\n",
    "    MPD[FCS] = MRX\n",
    "    MFM = np.dot(MG, MPD)\n",
    "    FC = np.array([])\n",
    "    MF = np.array([])\n",
    "    for i in range(sum(N_E)):\n",
    "        MLR = np.dot(ML[i], MPD[(2 * i):(2 * i + 4)])\n",
    "        FC = np.concatenate((FC, MLR[0], MLR[2]))\n",
    "        MF = np.concatenate((MF, MLR[1], MLR[3]))\n",
    "    RD = MPD[range(0, len(MPD), 2)]\n",
    "    RP = MPD[range(1, len(MPD), 2)]\n",
    "    Dom = np.unique(np.concatenate((np.linspace(0, FloatSlider3.value, BoundedFloatText5.value + 2), np.linspace(FloatSlider3.value, BoundedFloatText4.value, BoundedFloatText5.value + 2))))\n",
    "    return RD, RP, MF, FC, MRA, MRB, MRX, Dom\n",
    "        \n",
    "def sym_calc(L, EI, AE, AF, F, M, D):\n",
    "    Lon_Tra = L\n",
    "    Ine_You = EI\n",
    "    Apo_Ela = AE\n",
    "    Apo_Fij = AF\n",
    "    Fue_Nod = F\n",
    "    Mom_Nod = M\n",
    "    Fue_Dis = D\n",
    "\n",
    "    Nod_Tot = np.concatenate((np.array([0]), np.cumsum(Lon_Tra[0:2])))\n",
    "    Nod_Ini = Nod_Tot[0:2]\n",
    "    Nod_Fin = Nod_Tot[1:3]\n",
    "    Apo_Tot = Apo_Ela + Apo_Fij\n",
    "\n",
    "    nvr = ''\n",
    "    for i in range(1,np.shape(np.nonzero(Apo_Tot))[1] + 1):\n",
    "            var = ' r' + str(i)\n",
    "            nvr = nvr + var\n",
    "    Cons_0  = sp.var(nvr)\n",
    "    Rea_Fue = np.array([0, 0 ,0], dtype = object)\n",
    "    Rea_Fue[Apo_Tot > 0] = Cons_0\n",
    "    Fue_Nod = Fue_Nod + Rea_Fue\n",
    "\n",
    "    if sum(Apo_Fij) != 0:\n",
    "        nvr = ''\n",
    "        for i in range(1,np.shape(np.nonzero(Apo_Fij))[1] + 1):\n",
    "                var = ' m' + str(i)\n",
    "                nvr = nvr + var\n",
    "        Cons_1  = sp.var(nvr)\n",
    "        Rea_Mom = np.array([0, 0 ,0], dtype = object)\n",
    "        Rea_Mom[Apo_Fij > 0] = Cons_1\n",
    "        Mom_Nod = Mom_Nod + Rea_Mom\n",
    "\n",
    "    x = sp.var('x'); x1 = sp.var('x1'); x2 = sp.var('x2')\n",
    "    Com_Fue = np.array([0, 0], dtype = object)\n",
    "    Com_Dis = np.array([0, 0], dtype = object)\n",
    "    for i in range(2):\n",
    "        Com_Fue[i] = sum(Fue_Nod[0:i + 1])\n",
    "        Com_Dis[i] = Fue_Dis[i] * (x - Nod_Ini[i])\n",
    "    Fue_Equ = Fue_Dis * (Nod_Fin - Nod_Ini)\n",
    "    Fue_Equ = np.concatenate((np.array([0]), np.cumsum(Fue_Equ[0:1])))\n",
    "\n",
    "    Ecu_Cor = np.array([0, 0], dtype = object)\n",
    "    for i in range(2):\n",
    "        Ecu_Cor[i] = Com_Fue[i] + Com_Dis[i] + Fue_Equ[i]\n",
    "\n",
    "    x1 = 0\n",
    "    Ecu_Mom = np.array([0, 0], dtype = object)\n",
    "    for i in range(2):\n",
    "        Ecu_1      = sp.integrate(Ecu_Cor[i], x) + x2 + Mom_Nod[i] - x1\n",
    "        Ecu_1      = Ecu_1.subs(x, Nod_Ini[i])\n",
    "        Ecu_2      = sp.integrate(Ecu_Cor[i], x) + np.array(solve(Ecu_1, x2))[0]\n",
    "        Ecu_Mom[i] = Ecu_2\n",
    "        x1         = Ecu_2.subs(x, Nod_Fin[i])   \n",
    "    Sho_Mom = Ecu_Mom[0]    \n",
    "    Sis_Fue = sum(Fue_Nod) + sum(Fue_Dis * (Nod_Fin - Nod_Ini))\n",
    "    Sis_Mom = sum(Mom_Nod) + sum(Nod_Fin * Fue_Nod[1:]) + sum((Fue_Dis * (Nod_Fin - Nod_Ini)) * ((Nod_Fin + Nod_Ini) / 2))\n",
    "\n",
    "    Ecu_Pen = np.array([0, 0], dtype = object)\n",
    "    Ecu_Def = np.array([0, 0], dtype = object)\n",
    "    for i in range(2):\n",
    "        Ecu_Pen[i] = sp.integrate(Ecu_Mom[i], x) + sp.var('c' + str(2 * (i + 1) - 1))\n",
    "        Ecu_Def[i] = sp.integrate(Ecu_Pen[i], x) + sp.var('c' + str(2 * (i + 1)))\n",
    "    Sho_Def = Ecu_Def[0]\n",
    "    Sis_Pen = Ecu_Pen[1].subs(x, Nod_Fin[0]) / Ine_You - Ecu_Pen[0].subs(x, Nod_Fin[0]) / Ine_You\n",
    "    Sis_Def = Ecu_Def[1].subs(x, Nod_Fin[0]) / Ine_You - Ecu_Def[0].subs(x, Nod_Fin[0]) / Ine_You\n",
    "\n",
    "    Sis_Nod = np.array([0, 0], dtype = object)\n",
    "    Sis_Nod[0] = Ecu_Def[0].subs(x, Nod_Tot[0])\n",
    "    Sis_Nod[1] = Ecu_Def[1].subs(x, Nod_Tot[2])\n",
    "    if sum(Apo_Fij) != 0: \n",
    "        Sis_Nop = np.zeros((1, np.count_nonzero(Apo_Fij)), dtype = object)[0]\n",
    "        j = -1\n",
    "        for i in range(3):\n",
    "            if Apo_Fij[i] != 0:\n",
    "                j = j + 1\n",
    "                if Apo_Fij[i] == 1:\n",
    "                    Sis_Nop[j] = Ecu_Pen[0].subs(x, Nod_Tot[i])\n",
    "                elif Apo_Fij[i] == 3:\n",
    "                    Sis_Nop[j] = Ecu_Pen[1].subs(x, Nod_Tot[i])\n",
    "        if len(Sis_Nop) == 1:\n",
    "            Sis_Ecu = (Sis_Fue, Sis_Mom, Sis_Pen, Sis_Def, Sis_Nod[0], Sis_Nod[1], Sis_Nop[0])\n",
    "        else:\n",
    "            Sis_Ecu = (Sis_Fue, Sis_Mom, Sis_Pen, Sis_Def, Sis_Nod[0], Sis_Nod[1], Sis_Nop[0], Sis_Nop[1])\n",
    "    else:\n",
    "        Sis_Ecu = (Sis_Fue, Sis_Mom, Sis_Pen, Sis_Def, Sis_Nod[0], Sis_Nod[1])\n",
    "    rpts = sp.solve(Sis_Ecu)\n",
    "\n",
    "    for i in range(2):\n",
    "        Ecu_Def[i] = Ecu_Def[i].subs(c1, rpts[c1])\n",
    "        Ecu_Def[i] = Ecu_Def[i].subs(c2, rpts[c2])\n",
    "        Ecu_Def[i] = Ecu_Def[i].subs(c3, rpts[c3])\n",
    "        Ecu_Def[i] = Ecu_Def[i].subs(c4, rpts[c4])\n",
    "        Ecu_Def[i] = Ecu_Def[i].subs(r1, rpts[r1])\n",
    "        if sum(Apo_Fij) != 0: \n",
    "            Ecu_Def[i] = Ecu_Def[i].subs(m1, rpts[m1])\n",
    "\n",
    "    Ecu_Def = Ecu_Def / Ine_You\n",
    "    for i in range(2):\n",
    "        Ecu_Pen[i] = sp.diff(Ecu_Def[i], x)\n",
    "        Ecu_Mom[i] = sp.diff(Ecu_Pen[i], x) * Ine_You\n",
    "        Ecu_Cor[i] = sp.diff(Ecu_Mom[i], x)\n",
    "    numel = int(np.round((FloatSlider3.value / BoundedFloatText4.value) * 100))\n",
    "    Dom = np.array([np.linspace(Nod_Tot[0], Nod_Tot[1], numel), np.linspace(Nod_Tot[1], Nod_Tot[2], 100 - numel)], dtype = 'object')\n",
    "    Val_Def = np.array([])\n",
    "    Val_Pen = np.array([])\n",
    "    Val_Mom = np.array([])\n",
    "    Val_Cor = np.array([])\n",
    "    for i in range(2):\n",
    "        flamb = lambdify(x, Ecu_Def[i], \"numpy\")\n",
    "        Val_Def = np.append(Val_Def, flamb(Dom[i]))\n",
    "        flamb = lambdify(x, Ecu_Pen[i], \"numpy\")\n",
    "        Val_Pen = np.append(Val_Pen, flamb(Dom[i]))\n",
    "        flamb = lambdify(x, Ecu_Mom[i], \"numpy\")\n",
    "        Val_Mom = np.append(Val_Mom, flamb(Dom[i]))\n",
    "        flamb = lambdify(x, Ecu_Cor[i], \"numpy\")\n",
    "        Val_Cor = np.append(Val_Cor, flamb(Dom[i]))\n",
    "    Dom = np.concatenate([Dom[0], Dom[1]]).reshape(100,) * 1000\n",
    "    return Val_Def, Val_Pen, Val_Mom, Val_Cor, Sho_Mom, Sho_Def, Sis_Ecu, rpts, Ecu_Def[0], Ecu_Mom[0], Dom\n",
    "\n",
    "def shaft_calc(valor):\n",
    "    global Sim_Def, Sim_Pen, Sim_Mom, Sim_Cor, Dom, Num_Def, Num_Pen, Num_Mom, Num_Cor, NDom\n",
    "    L = np.array([FloatSlider3.value / 1000, (BoundedFloatText4.value - FloatSlider3.value) / 1000])\n",
    "    EI = 2e11 * ((np.pi / 64) * ((BoundedFloatText2.value / 1000) ** 4 - (BoundedFloatText3.value / 1000) ** 4))\n",
    "    AE = np.array([0, 0, 0])\n",
    "    AF = np.array([0, 0, 0])\n",
    "    if Dropdown1.value == 'Elastico':\n",
    "        AE[0] = 1\n",
    "    else:\n",
    "        AF[0] = 1\n",
    "    if Dropdown2.value == 'Elastico':\n",
    "        AE[2] = 3\n",
    "    else:\n",
    "        AF[2] = 3\n",
    "    F = np.array([0, FloatText2.value * 1000, 0])\n",
    "    M = np.array([0, FloatText3.value * 1000, 0])\n",
    "    if Checkbox1.value == True:\n",
    "        D = ((np.pi / 4) * ((BoundedFloatText2.value / 1000) ** 2 - (BoundedFloatText3.value / 1000) ** 2)) * BoundedFloatText1.value * 9.81\n",
    "        D = np.array([-D, -D])\n",
    "    else:\n",
    "        D = np.array([0, 0])\n",
    "    Sim_Def, Sim_Pen, Sim_Mom, Sim_Cor, Sho_Mom, Sho_Def, Sis_Ecu, rpts, Ecu_Def, Ecu_Mom, Dom = sym_calc(L, EI, AE, AF, F, M, D)\n",
    "    HTMLMath16.value = f'${latex(Sho_Mom)}$'\n",
    "    HTMLMath17.value = f'${latex(Sho_Def)}$'\n",
    "    HTMLMath18.value = f'${latex(Sis_Ecu)}$'\n",
    "    HTMLMath19.value = f'${latex(rpts)}$'\n",
    "    HTMLMath20.value = f'${latex(Ecu_Def)}$'\n",
    "    HTMLMath21.value = f'${latex(Ecu_Mom)}$'\n",
    "    \n",
    "    E  = 2e11\n",
    "    I  = (np.pi / 64) * ((BoundedFloatText2.value / 1000) ** 4 - (BoundedFloatText3.value / 1000) ** 4)\n",
    "    G   = 77e9\n",
    "    Num_Def, Num_Pen, Num_Mom, Num_Cor, MRA, MRB, MRX, NDom = num_calc(L, E, I, G)\n",
    "    if BoundedFloatText5.value > 3:\n",
    "        P = np.linspace(0, len(MRA) - 1, 14, dtype = 'int')\n",
    "        MRA = MRA[P[:,np.newaxis],P[np.newaxis,:]]\n",
    "        MRX = MRX[P]\n",
    "        MRB = MRB[P]\n",
    "    HTMLMath22.value = f'${latex(round_expr(sp.Matrix(MRA), 3))}$'\n",
    "    HTMLMath23.value = f'${latex(round_expr(sp.Matrix(MRX), 3))}$'\n",
    "    HTMLMath24.value = f'${latex(round_expr(sp.Matrix(MRB), 3))}$'  \n",
    "        \n",
    "    X = Dom\n",
    "    Y = abs(Sim_Def)\n",
    "    S1 = np.trapz(y = Y, x = X)\n",
    "    S2 = np.trapz(y = Y ** 2, x = X)\n",
    "    Sim_Vcr = (30 / np.pi) * np.sqrt(9.81 * abs(S1/ S2))\n",
    "    X = NDom\n",
    "    Y = abs(Num_Def.T[0])\n",
    "    S1 = np.trapz(y = Y, x = X)\n",
    "    S2 = np.trapz(y = Y ** 2, x = X)\n",
    "    Num_Vcr = (30 / np.pi) * np.sqrt(9.81 * abs(S1/ S2))\n",
    "    sheet1.cells = (\n",
    "    ips.Cell(column_end=0, column_start=0, row_end=0, row_start=0, type='text', value=str(max(abs(Sim_Def)))),\n",
    "    ips.Cell(column_end=1, column_start=1, row_end=0, row_start=0, type='text', value=str(Sim_Vcr)),\n",
    "    ips.Cell(column_end=0, column_start=0, row_end=1, row_start=1, type='text', value=str(max(abs(Num_Def.T[0])))),\n",
    "    ips.Cell(column_end=1, column_start=1, row_end=1, row_start=1, type='text', value=str(Num_Vcr)),\n",
    "    ips.Cell(column_end=0, column_start=0, row_end=2, row_start=2, type='text', value=str(abs(((max(abs(Sim_Def)) - max(abs(Num_Def.T[0]))) / max(abs(Num_Def.T[0]))) * 100))),\n",
    "    ips.Cell(column_end=1, column_start=1, row_end=2, row_start=2, type='text', value=str(abs(((Sim_Vcr - Num_Vcr) / Num_Vcr) * 100)))\n",
    "    )\n",
    "Button1.on_click(shaft_calc)\n",
    "\n",
    "def draw_graph(valor):\n",
    "    if Dropdown3.value == 'Cortantes':\n",
    "        ylabel = 'Cortantes (N)'\n",
    "        if Checkbox1.value == False:\n",
    "            YDom = np.repeat(Sim_Cor, 50)\n",
    "        else:\n",
    "            YDom = Sim_Cor\n",
    "        DomY = Num_Cor[range(0, len(Num_Cor), 2)]\n",
    "        DomY = np.append(DomY, -Num_Cor[-1])\n",
    "    elif Dropdown3.value == 'Momentos':\n",
    "        ylabel = 'Momentos (N.m)'\n",
    "        YDom = Sim_Mom\n",
    "        DomY = Num_Mom[range(0, len(Num_Mom), 2)]\n",
    "        DomY = -np.append(DomY, -Num_Mom[-1])\n",
    "    elif Dropdown3.value == 'Pendientes':\n",
    "        ylabel = 'Pendientes (rad)'\n",
    "        YDom = Sim_Pen\n",
    "        DomY = Num_Pen.T[0]\n",
    "    elif Dropdown3.value == 'Deflexiones':\n",
    "        ylabel = 'Deflexiones (mm)'\n",
    "        YDom = Sim_Def * 1000\n",
    "        DomY = Num_Def.T[0] * 1000\n",
    "    Scatter4.x = NDom\n",
    "    Scatter4.y = DomY\n",
    "    Scatter4.tooltip = bqp.Tooltip(fields = ['x', 'y'], formats = ['.2f', '.2f'])\n",
    "    Scatter4.names = None\n",
    "    XDom = np.insert(Dom, 0, 0)\n",
    "    XDom = np.append(XDom, BoundedFloatText4.value)\n",
    "    YDom = np.insert(YDom, 0, 0)\n",
    "    YDom = np.append(YDom, 0)\n",
    "    DomX = np.insert(NDom, 0, 0)\n",
    "    DomX = np.append(DomX, BoundedFloatText4.value)\n",
    "    DomY = np.insert(DomY, 0, 0)\n",
    "    DomY = np.append(DomY, 0)\n",
    "    Lines3.x = XDom\n",
    "    Lines3.y = YDom\n",
    "    Lines3.tooltip = bqp.Tooltip(fields = ['x', 'y'], formats = ['.2f', '.2f'])\n",
    "    Lines4.x = DomX\n",
    "    Lines4.y = DomY\n",
    "    fig4.axes[1].label = ylabel\n",
    "    fig5.axes[1].label = ylabel\n",
    "Button2.on_click(draw_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e7e28e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><font face=\"Times New Roman\"><font size=\"5\">\n",
    "    Presentacion de mi trabajo de tesis:\n",
    "</font></font></center>\n",
    "<hr>\n",
    "<br>\n",
    "<br>\n",
    "<center><font face=\"Times New Roman\"><font size=\"10\">\n",
    "    Desarrollo de una aplicacion computacional para el calculo de sistemas de transmisión de potencia\n",
    "</font></font></center>\n",
    "<br>\n",
    "<br>\n",
    "<hr>\n",
    "<center><font face=\"Times New Roman\"><font size=\"5\">\n",
    "    Autor: Aguilar Hancco Junior Joel\n",
    "</font></font></center>\n",
    "<center><font face=\"Times New Roman\"><font size=\"3\">Arequipa - 2022\n",
    "</font></font></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a2a821d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><font face=\"Times New Roman\"><font size=\"10\">\n",
    "    Calculo de factores provenientes de tablas (correas, cadenas, engranajes, ejes, etc)\n",
    "</font></font></center>\n",
    "<hr>\n",
    "<br>\n",
    "<font face=\"Times New Roman\"><font size=\"5\">\n",
    "Se realiza mediante interpolaciones unidimensionales y bidimensionales, de los datos previamente extraidos de las graficas, mediante procesamiento de imagenes.\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f7ead37a",
   "metadata": {
    "scrolled": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e72da14a5edc47b78905b30f599ee80f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(HTML(value='<center><font face=\"Times New Roman\"><font size=\"5\">                …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Componentes\n",
    "FloatSlider1 = ipw.FloatSlider(\n",
    "               description = 'r / D',\n",
    "               min = 0,\n",
    "               max = 0.3,\n",
    "               step = 0.01,\n",
    "               layout = ipw.Layout(margin = '0px 0px 30px 0px')\n",
    ")\n",
    "FloatSlider2 = ipw.FloatSlider(\n",
    "               description = 'D / d',\n",
    "               min = 1.02,\n",
    "               max = 1.5,\n",
    "               step = 0.01,\n",
    "               layout = ipw.Layout(margin = '0px 0px 30px 0px')\n",
    ")\n",
    "FloatText1   = ipw.FloatText(\n",
    "               description = 'K',\n",
    "               layout = ipw.Layout(width = '275px', margin = '0px 0px 60px 0px')\n",
    ")\n",
    "HTML1 = ipw.HTML(\n",
    "        value  = f'<center><font face=\"Times New Roman\"><font size=\"5\">\\\n",
    "                 Factor de concentracion de esfuerzo de un eje a flexion\\\n",
    "                 </font></font></center>',\n",
    "        layout = ipw.Layout(width = '330px', margin = '0px 0px 60px 0px')\n",
    ") \n",
    "HTML2 = ipw.HTML(\n",
    "        value  = f'<center><img src=\"Thesis/imag_pros.gif\" width=\"250\" height=\"250\"></center>',\n",
    "        layout = ipw.Layout(width = '330px', margin = '0px 0px 0px 0px')\n",
    ")\n",
    "\n",
    "with open(\"Thesis/Charts.jpg\", \"rb\") as f:\n",
    "    raw_image = f.read()   \n",
    "ipyimage = ipw.Image(value = raw_image, format = \"jpg\")\n",
    "\n",
    "scale_x1 = bqp.LinearScale(min = 0, max = 1)\n",
    "scale_y1 = bqp.LinearScale(min = 0, max = 1)\n",
    "ax_x1    = bqp.Axis(scale = scale_x1, label = '', color='white', grid_lines = 'none', visible = False)\n",
    "ax_y1    = bqp.Axis(scale = scale_y1, label = '', color='white', orientation = 'vertical', grid_lines = 'none', visible = False)\n",
    "scales1  = {\"x\": scale_x1, \"y\": scale_y1}\n",
    "panzoom  = bqp.interacts.PanZoom(scales={'x': [scale_x1], 'y': [scale_y1]})\n",
    "m_fig    = dict(left = 45, top = 0, bottom = 35, right = 15)\n",
    "\n",
    "imagen1  = bqp.Image(image = ipyimage, scales = scales1)\n",
    "lines1   = bqp.Lines(x = [], y = [],\n",
    "           scales = {'x': scale_x1, 'y': scale_y1,},\n",
    "           colors = ['red'],\n",
    "           line_style = 'dashed'\n",
    ")\n",
    "scatter1 = bqp.Scatter(x = [], y = [],\n",
    "           scales = {'x': scale_x1, 'y': scale_y1,},\n",
    "           default_size = int(25),\n",
    "           colors = ['red'],\n",
    "           marker = 'circle'\n",
    ")\n",
    "\n",
    "fig1 = bqp.Figure(marks = [imagen1, lines1, scatter1], axes = [ax_x1, ax_y1], fig_margin = m_fig, padding_x = 0, padding_y = 0, layout = ipw.Layout(width = '650px', height = '650px'))\n",
    "fig1.interaction = panzoom\n",
    "fig1.max_aspect_ratio = 10\n",
    "fig1.min_aspect_ratio = 1\n",
    "\n",
    "VBox1 = ipw.VBox([HTML1, FloatSlider1, FloatSlider2, FloatText1, HTML2], \n",
    "        layout = ipw.Layout(justify_content = 'flex-start', width = 'auto', height = 'auto', margin = '0px', padding = '0px', border = '0px'))\n",
    "HBox1 = ipw.HBox([VBox1, fig1])\n",
    "display(HBox1)\n",
    "\n",
    "# Funciones\n",
    "x = np.array([0.00, 0.04, 0.08, 0.12, 0.16, 0.20, 0.24, 0.28, 0.30])\n",
    "y = np.array([1.02, 1.05, 1.50])\n",
    "z = np.array([[2.40, 1.88, 1.62, 1.50, 1.42, 1.36, 1.34, 1.32, 1.30], \n",
    "              [2.90, 2.26, 1.85, 1.67, 1.56, 1.47, 1.42, 1.38, 1.37],\n",
    "              [3.30, 2.67, 2.14, 1.86, 1.71, 1.60, 1.52, 1.47, 1.45]\n",
    "])\n",
    "f1 = numint.interp2d(x, y, z)\n",
    "x  = np.array([0.000, 0.300])\n",
    "y  = np.array([0.110, 0.985])\n",
    "f2 = numint.interp1d(x, y)\n",
    "x  = np.array([1.000, 3.000])\n",
    "y  = np.array([0.060, 0.995])\n",
    "f3 = numint.interp1d(x, y)\n",
    "def funcion1(valor):\n",
    "    lines1.x = [f2(valor), f2(valor), f2(0)]\n",
    "    lines1.y = [f3(1), f3(f1(valor, FloatSlider2.value)[0]), f3(f1(valor, FloatSlider2.value)[0])]\n",
    "    scatter1.x = [f2(valor)]\n",
    "    scatter1.y = [f3(f1(valor, FloatSlider2.value)[0])]\n",
    "    FloatText1.value = f1(valor, FloatSlider2.value)[0]\n",
    "f_funcion1 = ipw.interactive(funcion1, valor = FloatSlider1)\n",
    "def funcion2(valor):\n",
    "    lines1.x = [f2(FloatSlider1.value), f2(FloatSlider1.value), f2(0)]\n",
    "    lines1.y = [f3(1), f3(f1(FloatSlider1.value, valor)[0]), f3(f1(FloatSlider1.value, valor)[0])]\n",
    "    scatter1.x = [f2(FloatSlider1.value)]\n",
    "    scatter1.y = [f3(f1(FloatSlider1.value, valor)[0])]\n",
    "    FloatText1.value = f1(FloatSlider1.value, valor)[0]\n",
    "f_funcion2 = ipw.interactive(funcion2, valor = FloatSlider2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed478925",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```Octave\n",
    "% Programa para la digitalizacion de Imagenes\n",
    "% Autor: Junior Joel Aguilar Hancco\n",
    "\n",
    "clear, clc, close all\n",
    "Imagen   = input('Ingrense el nombre de su imagen:\\n','s'); clc\n",
    "im1      = imread(Imagen);\n",
    "figure('NumberTitle','Off','Name',Imagen)\n",
    "imshow(im1)\n",
    "disp('Seleccione dos puntos para establecer el sistema de escalamiento')\n",
    "[x1, y1] = ginput(2);\n",
    "cor1     = input('Ingrese el primer par coordenado entre corchetes:\\n'); clc\n",
    "cor2     = input('Ingrese el segundo par coordenado entre corchetes:\\n'); clc\n",
    "cor      = [cor1;cor2];\n",
    "npun     = input('¿Cuantos puntos desea obtener?\\n'); clc\n",
    "disp('Seleccione los puntos que desea obtener'); pause(2), clc\n",
    "[x2, y2] = ginput(npun);\n",
    "x3       = spline(x1, cor(:,1), x2);\n",
    "y3       = spline(y1, cor(:,2), y2);\n",
    "cor      = [x3';y3'];\n",
    "disp('Las coordenadas de los puntos seleccionados son:')\n",
    "disp('      X       Y')\n",
    "fprintf('\\t%.2f \\t%.2f\\n',cor)\n",
    "fig = figure('NumberTitle','Off','Name','Imagen Digitalizada');\n",
    "axe = axes('Parent',fig,'Color',[0 0 0]); hold(axe,'on')\n",
    "plot(x3,y3,'-r',x3,y3,'or','LineWidth',1.5)\n",
    "fig = gca; grid on\n",
    "fig.GridColor = [0 1 1];\n",
    "fig.GridAlpha = 0.5;\n",
    "fig.Layer = 'bottom';\n",
    "key1 = 0;\n",
    "while key1 == 0\n",
    "    cla; plot(x3,y3,'-r',x3,y3,'or','LineWidth',1.5)\n",
    "    n = input('Ingrese el grado del Polinomio de Aproximacion:\\n'); \n",
    "    f = polyfit(x3,y3,n);\n",
    "    f = poly2sym(f);\n",
    "    fplot(f,[min(x3) max(x3)],'Color',[0 0 1],'LineWidth',1.5); clc\n",
    "    r = input('¿Desea cambiar el grado del Polinomio?\\n','s');\n",
    "    switch r\n",
    "        case 'si'\n",
    "            key1 = 0;\n",
    "        case 'no'\n",
    "            key1 = 1; disp(f)\n",
    "    end\n",
    "end\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77f591d8",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<center><font face=\"Times New Roman\"><font size=\"10\">\n",
    "    Propiedes y parametros iniciales para el calculo del eje\n",
    "</font></font></center>\n",
    "<hr>\n",
    "<br>\n",
    "<font face=\"Times New Roman\"><font size=\"5\">\n",
    "Para dar un solucion optima al calculo del eje, es necesario establecer las propiedades geometricas y mecanicas, asi como otros parametros que describen al eje.\n",
    "</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d20d3570",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f1c68c71fa76451e9463d17876d28274",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Figure(fig_margin={'top': 60, 'bottom': 60, 'left': 60, 'right': 60}, layout=Layout(height='600px', width='140…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "HTMLMath1 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$Q=\\frac{D^3-d^3}{12}$$\",\n",
    ")\n",
    "HTMLMath2 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$I=\\frac{\\pi \\left(D^4-d^4\\right)}{64}$$\",\n",
    ")\n",
    "HTMLMath3 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$J=\\frac{\\pi \\left(D^4-d^4\\right)}{32}$$\",\n",
    ")\n",
    "HTMLMath4 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$A=\\frac{\\pi \\left(D^4-d^4\\right)}{4}$$\",\n",
    ")\n",
    "HTMLMath5 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$${M_k}(x) =  - x\\sum\\limits_{i = 1}^k {{F_i}}  - \\frac{1}{2}{w_k}{(x - {x_k})^2} - x\\sum\\limits_{i = 0}^{k - 1} {{w_i}({x_{i + 1}} - {x_i})}  + {C_{{1_k}}} + {M_k}\\quad para\\;k = 1\\; \\to \\;T$$\",\n",
    ")\n",
    "HTMLMath6 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$${y_k}(x) = \\frac{{ - \\frac{{{x^3}}}{6}\\sum\\limits_{i = 1}^k {{F_i}}  - \\frac{1}{{24}}{w_k}{{(x - {x_k})}^4} - \\frac{{{x^3}}}{6}\\sum\\limits_{i = 0}^{k - 1} {{w_i}({x_{i + 1}} - {x_i})}  + \\frac{{{C_{{1_k}}}{x^2}}}{2} + \\frac{{{M_k}{x^2}}}{2} + {C_{{2_k}}}x + {C_{{3_k}}}}}{{{E_k}{I_k}}}\\;$$\",\n",
    ")\n",
    "HTMLMath7 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$${\\sigma _k} = \\frac{{M{{(x)}_k}{R_k}}}{{{I_k}}}\\quad para\\;k = 1\\; \\to \\;T$$\",\n",
    ")\n",
    "HTMLMath8 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$${\\sigma _{{{\\max }_X}}} = {K_x}\\frac{{M{{(x)}_x}{R_x}}}{{{I_x}}}\\quad para\\;x = 1\\; \\to \\;N$$\",\n",
    ")\n",
    "HTMLMath9 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$${\\sigma _k} = \\frac{{S{y_k}}}{{S{e_k}}}(\\sqrt {M_k^2(x) + 4V_k^2(x)}  + \\sqrt {A_k^2(x) + 4T_k^2(x)} )\\quad para\\;k = 1\\; \\to \\;T$$\",\n",
    ")\n",
    "HTMLMath10 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$${\\sigma _{{{\\max }_X}}} = {K_x}\\frac{{S{y_x}}}{{S{e_x}}}(\\sqrt {M_x^2(x) + 4V_x^2(x)}  + \\sqrt {A_x^2(x) + 4T_x^2(x)} )\\quad para\\;x = 1\\; \\to \\;N$$\",\n",
    ")\n",
    "HTMLMath11 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$F.S{._{estatic{o_K}}} = \\frac{{S{u_k}}}{{{\\sigma _k}}}\\quad para\\;k = 1\\; \\to \\;T$$\",\n",
    ")\n",
    "HTMLMath12 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$F.S{._{estatico\\;{{\\min }_X}}} = \\frac{{S{u_x}}}{{{\\sigma _{{{\\max }_X}}}}}\\quad para\\;x = 1\\; \\to \\;N$$\",\n",
    ")\n",
    "HTMLMath13 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$F.S{._{dinamic{o_K}}} = \\frac{{S{u_k}}}{{{\\sigma _k}}}\\quad para\\;k = 1\\; \\to \\;T$$\",\n",
    ")\n",
    "HTMLMath14 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$F.S{._{dinamico\\;{{\\min }_X}}} = \\frac{{S{u_x}}}{{{\\sigma _{{{\\max }_X}}}}}\\quad para\\;x = 1\\; \\to \\;N$$\",\n",
    ")\n",
    "HTMLMath15 = ipw.HTMLMath(\n",
    "    value = r\"<font size = '3'; font color = 'black'>$$V.C. = \\sum\\limits_{k = 1}^T {\\int\\limits_{{N_k}}^{{N_{k + 1}}} {(y_y^2{{(x)}_k}} }  + y_z^2{(x)_k})$$\",\n",
    ")\n",
    "\n",
    "def hide_formula(self, target):\n",
    "    graph.tooltip = None\n",
    "\n",
    "def show_formula(self, target):\n",
    "    name = target.get('data').get('label') \n",
    "    if name == 'Primer momento de area':\n",
    "        graph.tooltip = HTMLMath1\n",
    "    elif name == 'Segundo momento de area':\n",
    "        graph.tooltip = HTMLMath2\n",
    "    elif name == 'Momento polar de inercia':\n",
    "        graph.tooltip = HTMLMath3\n",
    "    elif name == 'Area de la seccion':\n",
    "        graph.tooltip = HTMLMath4\n",
    "    elif name == 'Reacciones':\n",
    "        graph.tooltip = HTMLMath5\n",
    "    elif name == 'Desplazamientos':\n",
    "        graph.tooltip = HTMLMath6\n",
    "    elif name == 'Esfuerzos estaticos':\n",
    "        graph.tooltip = HTMLMath7\n",
    "    elif name == 'Esfuerzos estaticos maximos':\n",
    "        graph.tooltip = HTMLMath8\n",
    "    elif name == 'Esfuerzos dinamicos':\n",
    "        graph.tooltip = HTMLMath9\n",
    "    elif name == 'Esfuerzos dinamicos maximos':\n",
    "        graph.tooltip = HTMLMath10\n",
    "    elif name == 'F.S. estaticos':\n",
    "        graph.tooltip = HTMLMath11\n",
    "    elif name == 'F.S. estaticos minimos':\n",
    "        graph.tooltip = HTMLMath12\n",
    "    elif name == 'F.S. dinamicos':\n",
    "        graph.tooltip = HTMLMath13\n",
    "    elif name == 'F.S. dinamicos minimos':\n",
    "        graph.tooltip = HTMLMath14\n",
    "    elif name == 'Velocidades criticas':\n",
    "        graph.tooltip = HTMLMath15\n",
    "    else:\n",
    "        graph.tooltip = None\n",
    "\n",
    "node_data = [\n",
    "    {'label': 'Tipos de apoyo', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Fuerzas', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Momentos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Numero de nodos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Condiciones de operación', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Tratamiento superficial', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Módulo de elasticidad', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Módulo de rigidez', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Esfuerzo de fluencia', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Esfuerzo de rotura', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Densidad', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Diametro mayor', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Diametro menor', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Longitud', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Redondeos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Primer momento de area', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Segundo momento de area', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Momento polar de inercia', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Area de la seccion', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Reacciones', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Desplazamientos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Esfuerzos estaticos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Esfuerzos estaticos maximos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Esfuerzos dinamicos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Esfuerzos dinamicos maximos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'F.S. estaticos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'F.S. estaticos minimos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'F.S. dinamicos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'F.S. dinamicos minimos', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "    {'label': 'Velocidades criticas', 'shape': 'rect', 'shape_attrs': {'rx': 5, 'ry': 5, 'width': 170, 'height': 30}},\n",
    "]\n",
    "\n",
    "link_data = [{'source': 0, 'target': 20},\n",
    "             {'source': 1, 'target': 19},\n",
    "             {'source': 2, 'target': 19},\n",
    "             {'source': 4, 'target': 23},\n",
    "             {'source': 5, 'target': 23},\n",
    "             {'source': 6, 'target': 20},\n",
    "             {'source': 7, 'target': 20},\n",
    "             {'source': 8, 'target': 25},\n",
    "             {'source': 8, 'target': 26},\n",
    "             {'source': 9, 'target': 27},\n",
    "             {'source': 9, 'target': 28},\n",
    "             {'source': 10, 'target': 20},\n",
    "             {'source': 11, 'target': 15},\n",
    "             {'source': 11, 'target': 16},\n",
    "             {'source': 11, 'target': 17},\n",
    "             {'source': 11, 'target': 18},\n",
    "             {'source': 12, 'target': 15},\n",
    "             {'source': 12, 'target': 16},\n",
    "             {'source': 12, 'target': 17},\n",
    "             {'source': 12, 'target': 18},\n",
    "             {'source': 13, 'target': 19},\n",
    "             {'source': 14, 'target': 22},\n",
    "             {'source': 14, 'target': 24},\n",
    "             {'source': 15, 'target': 21},\n",
    "             {'source': 15, 'target': 23},\n",
    "             {'source': 16, 'target': 21},\n",
    "             {'source': 16, 'target': 23},\n",
    "             {'source': 17, 'target': 21},\n",
    "             {'source': 17, 'target': 23},\n",
    "             {'source': 18, 'target': 20},\n",
    "             {'source': 18, 'target': 21},\n",
    "             {'source': 19, 'target': 20},\n",
    "             {'source': 20, 'target': 19},\n",
    "             {'source': 20, 'target': 21},\n",
    "             {'source': 20, 'target': 23},\n",
    "             {'source': 20, 'target': 29},\n",
    "             {'source': 21, 'target': 22},\n",
    "             {'source': 21, 'target': 25},\n",
    "             {'source': 22, 'target': 26},\n",
    "             {'source': 23, 'target': 24},\n",
    "             {'source': 23, 'target': 27},\n",
    "             {'source': 24, 'target': 28}]\n",
    "\n",
    "x = np.concatenate((np.array([0] * 6), np.array([50] * 5), np.array([100] * 4), np.array([150] * 4), np.array([200] * 6), np.array([250] * 5)))\n",
    "y = np.concatenate((np.linspace(1, 2 * 6 - 1, 6), np.linspace(2, 2 * 5, 5), np.linspace(3, 2 * 4 + 1, 4), np.linspace(3, 2 * 4 + 1, 4), np.linspace(1, 2 * 6 - 1, 6), np.linspace(2, 2 * 5, 5)))\n",
    "graph = bqp.Graph(node_data = node_data, link_data = link_data, link_type = 'slant_line', hovered_style = {'stroke': 'black', 'stroke-width': '3'}, unhovered_style = {'opacity': '0.1'},\n",
    "              colors=['#F1948A'] * 3 + ['#F4D03F'] * 1 + ['#F1948A'] * 2 + ['#82E0AA'] * 5 + ['#7FB3D5'] * 4 + ['#E5E7E9'] * (len(node_data) - 15),\n",
    "              scales={'x': bqp.LinearScale(), 'y': bqp.LinearScale(), }, x = x, y = y, \n",
    "              directed = True)\n",
    "fig2 = bqp.Figure(title = 'Dependencias', marks = [graph], layout = ipw.Layout(width='1400px', height='600px'))\n",
    "graph.on_hover(show_formula)\n",
    "graph.on_element_click(hide_formula)\n",
    "display(fig2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caf465bc",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "$$\n",
    "\\begin{align}\n",
    "\\text{Probability density function:}\\\\\n",
    "\\begin{cases}\n",
    "\\frac{1}{b-a}&\\text{for $x\\in[a,b]$}\\\\\n",
    "0&\\text{otherwise}\\\\\n",
    "\\end{cases}\n",
    "\\\\\n",
    "\\text{Cumulative distribution function:}\\\\\n",
    "\\begin{cases}\n",
    "0&\\text{for $x<a$}\\\\\n",
    "\\frac{x-a}{b-a}&\\text{for $x\\in[a,b)$}\\\\\n",
    "1&\\text{for $x\\ge b$}\\\\\n",
    "\\end{cases}\n",
    "\\end{align}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "971e4734",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<!-- background-image: url('RetroWave.jpg'); background-size: cover -->\n",
       "<!DOCTYPE html>\n",
       "<html>\n",
       "    <body style=\"background-color: rgb(255, 255, 255);\">\n",
       "    \n",
       "    <h1 style=\"color: cyan; font-size: 41px; font-family: 'Courier New'; background-color: rgb(135, 132, 114); border: 0px; text-align: left; padding: 0px 0px 0px 0px\"><b><center>Dibujando con epiciclos y la transformada de Fourier</center></b></h1>\n",
       "</html>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<!-- background-image: url('RetroWave.jpg'); background-size: cover -->\n",
    "<!DOCTYPE html>\n",
    "<html>\n",
    "    <body style=\"background-color: rgb(255, 255, 255);\">\n",
    "    \n",
    "    <h1 style=\"color: cyan; font-size: 41px; font-family: 'Courier New'; background-color: rgb(135, 132, 114); border: 0px; text-align: left; padding: 0px 0px 0px 0px\"><b><center>Dibujando con epiciclos y la transformada de Fourier</center></b></h1>\n",
    "</html>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0813d0cd",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "> Text that will be indented when the Markdown is rendered.\n",
    ">> Text that will be indented when the Markdown is rendered."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 122.844,
   "position": {
    "height": "351.844px",
    "left": "990px",
    "right": "20px",
    "top": "119px",
    "width": "356px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}