docs/nusa-info/es/spring-element.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Elemento Spring\n",
    "\n",
    "## Fundamento teórico\n",
    "\n",
    "El elemento *Spring* es un elemento finito unidimensional donde \n",
    "las coordenadas locales y globales coinciden. Cada elemento spring tiene dos \n",
    "nodos como se muestra en la figura siguiete. Sea la rigidez del \n",
    "resorte la denotada por $k$, en este caso la matriz de rigidez del elemento está \n",
    "dada por:\n",
    "\n",
    "\\begin{equation}\n",
    "K_{(e)} = \\begin{bmatrix}\n",
    "k & -k \\\\\n",
    "-k & k \n",
    "\\end{bmatrix}\n",
    "\\end{equation}\n",
    "\n",
    "![](src/spring-element/spring_element.PNG)\n",
    "\n",
    "Obviamente la matriz de rigidez para un elemento *spring* es de $2\\,x\\,2$, dado que \n",
    "este tiene dos grados de libertada, uno en cada nodo. Consecuentemente para un \n",
    "sistema de elementos *spring* con $n$ nodos, el tamaño de la matriz global de \n",
    "rigidez $K$ será de $n\\,x\\,n$. La matriz global de rigidez se obtiene ensamblando \n",
    "los matrices de rigidez por elemento $K_{(i)}$ para $i=1,2,...,n$, utilizando el método \n",
    "directo de la rigidez.\n",
    "\n",
    "Una vez que la matriz global de rigidez $K$ es obtenida  se tiene un sistema de ecuaciones \n",
    "de la forma:\n",
    "\n",
    "\\begin{equation}\n",
    "[K]\\{U\\} = \\{F\\}\n",
    "\\end{equation}\n",
    "\n",
    "Donde $U$ es el vector global de desplazamientos nodales y $F$ es el vector global de \n",
    "fuerzas nodales.\n",
    "\n",
    "El sistema de ecuaciones resultantes se puede simplificar aplicando las condiciones \n",
    "de frontera o restricciones de desplazamiento, quedando generalmente un sistema \n",
    "de menor dimensión el cuál está determinado y puede resolverse utilizando métodos \n",
    "de álgebra lineal´, quedando una posible solución como:\n",
    "\n",
    "\\begin{equation}\n",
    "\\overline{U} = \\overline{K}^{-1}\\, \\overline{F}\n",
    "\\end{equation}\n",
    "\n",
    "Donde $\\overline{U}, \\overline{K} \\,\\, y \\,\\, \\overline{F}$ corresponden a las variables descritas \n",
    "anteriormente, después de aplicar las condiciones de frontera correspondientes.\n",
    "\n",
    "\n",
    "## Un ejemplo resuelto en NuSA\n",
    "\n",
    "**Ejemplo 1.** Para el ensamble mostrado en la figura siguiente, calcular \n",
    "a) la matriz global de rigidez  b) los desplazamientos de los nodos 3 y 4  c) las fuerzas \n",
    "de reacción en los nodos 1 y 2, y  d) las fuerzas en cada elemento. Una fuerza de 5000 lb \n",
    "es aplicada en el nodo 4 en la dirección $x$, las constantes de rigidez para cada resorte \n",
    "se muestran en la figura. Los nodos 1 y 2 están fijos.\n",
    "\n",
    "![](src/spring-element/example_01.PNG)\n",
    "\n",
    "Los pasos para solucionar el problema utilizando NuSA se resumen en la siguiente \n",
    "lista:\n",
    "\n",
    "1. Importar las librerías a utilizar\n",
    "2. Definir constantes o datos de entrada \n",
    "1. Crear un modelo del tipo correspondiente\n",
    "1. Crear nodos y elementos\n",
    "1. Agregar los nodos y elementos al modelo\n",
    "1. Indicar las cargas y condiciones de frontera \n",
    "1. Resolver el modelo\n",
    "1. Consultar los datos de salida requeridos\n",
    "\n",
    "Siguiendo la metodología anterior, vamos a ir *desmenuzando* cada uno de los \n",
    "puntos expuestos.\n",
    "\n",
    "#### Importar las librerías a utilizar\n",
    "\n",
    "Se importan los módulos `core`, `model` y `element`, que contienen \n",
    "todas las clases necesarias para crear y solucionar el modelo de elemento finito.\n",
    "\n",
    "```\n",
    "from nusa.core import *\n",
    "from nusa.model import *\n",
    "from nusa.element import *\n",
    "```\n",
    "\n",
    "#### Definir constantes o datos de entrada\n",
    "\n",
    "En esta paso se crean variables con datos a utilizar en el resto del procedimiento, las \n",
    "cuales pueden ser fuerzas nodales aplicadas, desplazamientos preescritos, o bien constantes \n",
    "mecánicas del material.\n",
    "\n",
    "Para nuestro ejemplo se definen la fuerza $P$ aplicada en el nodo 4 y las constantes de rigidez \n",
    "para cada resorte.\n",
    "\n",
    "```\n",
    "# Definiendo constantes\n",
    "P = 5000.0\n",
    "k1, k2, k3 = 1000, 2000, 3000\n",
    "```\n",
    "\n",
    "#### Crear un modelo de tipo correspondiente\n",
    "\n",
    "Para este caso se crea un modelo instanciando un objeto de la clase `SpringModel`.\n",
    "\n",
    "```\n",
    "m1 = SpringModel(\"2D Model\")\n",
    "```\n",
    "\n",
    "Como puede notarse, el único argumento de entrada es un nombre para el modelo, mismo que no es necesario.\n",
    "\n",
    "\n",
    "#### Crear nodos y elementos\n",
    "\n",
    "```\n",
    "# Nodos\n",
    "n1 = Node((0,0))\n",
    "n2 = Node((0,0))\n",
    "n3 = Node((0,0))\n",
    "n4 = Node((0,0))\n",
    "# Elementos\n",
    "e1 = Spring((n1,n3),k1)\n",
    "e2 = Spring((n3,n4),k2)\n",
    "e3 = Spring((n4,n2),k3)\n",
    "```\n",
    "\n",
    "\n",
    "#### Agregar los nodos y elementos al modelo\n",
    "\n",
    "```\n",
    "for nd in (n1,n2,n3,n4):\n",
    "    m1.addNode(nd)\n",
    "for el in (e1,e2,e3):\n",
    "    m1.addElement(el)\n",
    "```\n",
    "\n",
    "#### Indicar las cargas y condiciones de frontera\n",
    "\n",
    "```\n",
    "m1.addForce(n4,(P,))\n",
    "m1.addConstraint(n1,ux=0)\n",
    "m1.addConstraint(n2,ux=0)\n",
    "```\n",
    "\n",
    "#### Resolver el modelo\n",
    "\n",
    "```\n",
    "m1.solve()\n",
    "```\n",
    "#### Consultar los datos de salida requeridos\n",
    "\n",
    "```\n",
    "# a) Matriz global\n",
    "print \"a) Matriz global:\\n {0}\".format(m1.KG)\n",
    "# b) Desplazamiento en los nodos 3 y 4\n",
    "print \"\\nb) Desplazamientos de nodos 3 y 4\"\n",
    "print \"UX3: {0}\".format(n3.ux)\n",
    "print \"UX4: {0}\".format(n4.ux)\n",
    "# c) Fuerzas de reacción en los nodos 1 y 2\n",
    "print \"\\nc) Fuerzas nodales en 1 y 2\"\n",
    "print \"FX1: {0}\".format(n1.fx)\n",
    "print \"FX2: {0}\".format(n2.fx)\n",
    "# d) Fuerzas en cada resorte\n",
    "print \"\\nd) Fuerzas en elementos\"\n",
    "print \"FE1:\\n {0}\".format(e1.fx)\n",
    "print \"FE2:\\n {0}\".format(e2.fx)\n",
    "print \"FE3:\\n {0}\".format(e3.fx)\n",
    "```\n",
    "\n",
    "Podemos, entonces, ejecutar el script resultante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a) Matriz global:\n",
      " [[ 1000.     0. -1000.     0.]\n",
      " [    0.  3000.     0. -3000.]\n",
      " [-1000.     0.  3000. -2000.]\n",
      " [    0. -3000. -2000.  5000.]]\n",
      "\n",
      "b) Desplazamientos de nodos 3 y 4\n",
      "UX3: 0.9090909090909092\n",
      "UX4: 1.3636363636363638\n",
      "\n",
      "c) Fuerzas nodales en 1 y 2\n",
      "FX1: -909.0909090909091\n",
      "FX2: -4090.9090909090914\n",
      "\n",
      "d) Fuerzas en elementos\n",
      "FE1:\n",
      " [[-909.09090909]\n",
      " [ 909.09090909]]\n",
      "FE2:\n",
      " [[-909.09090909]\n",
      " [ 909.09090909]]\n",
      "FE3:\n",
      " [[ 4090.90909091]\n",
      " [-4090.90909091]]\n"
     ]
    }
   ],
   "source": [
    "from nusa import *\n",
    "\n",
    "\"\"\"\n",
    "Logan, D. (2007). A first course in the finite element analysis.\n",
    "Example 2.1, pp. 42.\n",
    "\"\"\"\n",
    "P = 5000.0\n",
    "k1, k2, k3 = 1000, 2000, 3000\n",
    "# Model\n",
    "m1 = SpringModel(\"2D Model\")\n",
    "# Nodes\n",
    "n1 = Node((0,0))\n",
    "n2 = Node((0,0))\n",
    "n3 = Node((0,0))\n",
    "n4 = Node((0,0))\n",
    "# Elements\n",
    "e1 = Spring((n1,n3),k1)\n",
    "e2 = Spring((n3,n4),k2)\n",
    "e3 = Spring((n4,n2),k3)\n",
    "\n",
    "# Add elements \n",
    "for nd in (n1,n2,n3,n4):\n",
    "    m1.add_node(nd)\n",
    "for el in (e1,e2,e3):\n",
    "    m1.add_element(el)\n",
    "\n",
    "m1.add_force(n4,(P,))\n",
    "m1.add_constraint(n1,ux=0)\n",
    "m1.add_constraint(n2,ux=0)\n",
    "m1.solve()\n",
    "\n",
    "# a) Matriz global\n",
    "print(\"a) Matriz global:\\n {0}\".format(m1.KG))\n",
    "# b) Desplazamiento en los nodos 3 y 4\n",
    "print(\"\\nb) Desplazamientos de nodos 3 y 4\")\n",
    "print(\"UX3: {0}\".format(n3.ux))\n",
    "print(\"UX4: {0}\".format(n4.ux))\n",
    "# c) Fuerzas de reacción en los nodos 1 y 2\n",
    "print(\"\\nc) Fuerzas nodales en 1 y 2\")\n",
    "print(\"FX1: {0}\".format(n1.fx))\n",
    "print(\"FX2: {0}\".format(n2.fx))\n",
    "# d) Fuerzas en cada resorte\n",
    "print(\"\\nd) Fuerzas en elementos\")\n",
    "print(\"FE1:\\n {0}\".format(e1.fx))\n",
    "print(\"FE2:\\n {0}\".format(e2.fx))\n",
    "print(\"FE3:\\n {0}\".format(e3.fx))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}