Análisis de cerchas básico.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Contenido bajo licencia Creative Commons BY-NC-ND. El contenido de este Notebook es creado por Ana Beatriz Acevedo Jaramillo y Daniela González González 2020. Este material es parte del curso Análisis de Estructuras del programa de Ingeniería Civil de la Universidad EAFIT."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src= \n",
    "\"http://www.eafit.edu.co/biblioteca/PublishingImages/logos/eafit_apa.jpg\" \n",
    "         alt=\"GeeksforGeeks logo\" \n",
    "         align=\"left\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# *Análisis matricial de cerchas planas*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: justify;'> Este Notebook fue desarrollado como parte del material de apoyo para realizar el análisis de cerchas planas. Debe tener en cuenta que los datos de entrada que aparecen por defecto corresponden al ejercicio explicado en el documento que acompaña a este Notebook.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DATOS DE ENTRADA"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: justify;'> Esta sección contiene los datos que debe ingresar el usuario para que el Notebook realice en ánalisis de la estructura.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Información general de la estructura: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "Nn=4 #Número de nodos    \n",
    "Ne=5 #Número de elementos   \n",
    "NGLL=5 #Número de grados de libertad libres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con la información anterior se cálcula lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "NGL=2*Nn #Cálculo del número de grados de libertad\n",
    "NGLR=NGL-NGLL #Cálculo del número de grados de libertad restringidos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Grados de libertad asociados a cada elemento:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align}\n",
    "MGL = \\\\\n",
    "\\end{align} \n",
    "\\begin{bmatrix}\n",
    "gxi_{0} &gyi_{0} &gxf_{0} &gyf_{0}\\\\\n",
    "gxi_{1} &gyi_{1} &gxf_{1} &gyf_{1}\\\\\n",
    "gxi_{2} &gyi_{2} &gxf_{2} &gyf_{2}\\\\\n",
    ". &. &. &.\\\\\n",
    "gxi_{n} &gyi_{n} &gxf_{n} &gyf_{n}\\end{bmatrix}\\, .$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "MGL=[[6,7,2,3],[2,3,4,5],[6,7,0,1],[0,1,4,5],[0,1,2,3]] #Matriz con información de los grados de libertad asociados a cada elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Propiedades de los elementos: "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|MA|ME|\n",
    "|:-:|:-:|\n",
    "|$$\n",
    "\\begin{align}\n",
    "\\\\\n",
    "\\end{align} \n",
    "\\begin{bmatrix}\n",
    "A_{0}\\\\A_{1}\\\\A_{2}\\\\.\\\\A_{n}\\end{bmatrix}\\, $$|$$\n",
    "\\begin{align}\n",
    "\\\\\n",
    "\\end{align} \n",
    "\\begin{bmatrix}\n",
    "E_{0}\\\\E_{1}\\\\E_{2}\\\\.\\\\E_{n}\\end{bmatrix}\\, $$|\n",
    "                \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "MA=[[750],[750],[1000],[1000],[750]] #Matriz con las áreas de la sección transversal de cada elemento (en mm2).\n",
    "ME=[[200],[200],[200],[200],[200]] #Matriz con el módulo de elasticidad de cada elemento (en GPa)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Coordenadas de los nodos iniciales y finales de los elementos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\begin{align}\n",
    "MC = \\\\\n",
    "\\end{align} \n",
    "\\begin{bmatrix}\n",
    "xi_{0} &yi_{0} &xf_{0} &yf_{0}\\\\\n",
    "xi_{1} &yi_{1} &xf_{1} &yf_{1}\\\\\n",
    "xi_{2} &yi_{2} &xf_{2} &yf_{2}\\\\\n",
    ". &. &. &.\\\\\n",
    "xi_{n} &yi_{n} &xf_{n} &yf_{n}\\end{bmatrix}\\, .$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "MC=[[0,0,4000,3000],[4000,3000,8000,0],[0,0,4000,0],[4000,0,8000,0],[4000,0,4000,3000]] #Matriz que almacena las coordenadas de los nodos iniciales y finales de cada elemento (en mm)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cargas aplicadas en los nodos: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "F0=[[0],[-10],[0],[0],[20]] #Matriz de fuerzas aplicadas en los grados de libertad libres (en kN)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desplazamientos en los grados de libertad restringidos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "U1=[[0],[0],[0]] #Matriz de desplazamientos en los grados de libertad restringidos (en mm)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CÁLCULO DE REACCIONES Y DESPLAZAMIENTOS DE LA CERCHA:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: justify;'> En esta sección se procesan los datos ingresados para calcular las reacciones (fuerzas en los grados de libertad restringidos) y los desplazamientos de los grados de libertad libres.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de longitudes de los elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[5000.]\n",
      " [5000.]\n",
      " [4000.]\n",
      " [4000.]\n",
      " [3000.]]\n"
     ]
    }
   ],
   "source": [
    "ML=np.zeros((Ne,1)) #Matriz de almacenamiento de longitudes\n",
    "for i in range(Ne):\n",
    "    ML[i,0]=np.sqrt((MC[i][2]-MC[i][0])**2+(MC[i][3]-MC[i][1])**2)\n",
    "print(np.array(ML))\n",
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo y almacenamiento de la matriz de rigidez local de los elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAL=np.zeros((Ne,4,4)) #Matriz de almacenamiento de matrices de rigidez en coordenadas locales\n",
    "for i in range(Ne):\n",
    "    MAL[i,0,0]=(MA[i][0]*ME[i][0])/(ML[i][0])\n",
    "    MAL[i,0,2]=-MAL[i,0,0]\n",
    "    MAL[i,2,0]=-MAL[i,0,0]\n",
    "    MAL[i,2,2]=MAL[i,0,0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "*Visualización de la matriz de rigidez local de un elemento de la cercha:*\n",
    "\n",
    "Indique el número del elemento (n) para el cual desea ver la matriz de rigidez local.\n",
    "\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-30.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>-30.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>30.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0    1     2    3\n",
       "0  30.0  0.0 -30.0  0.0\n",
       "1   0.0  0.0   0.0  0.0\n",
       "2 -30.0  0.0  30.0  0.0\n",
       "3   0.0  0.0   0.0  0.0"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.DataFrame(MAL[n])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de la matriz de transformación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAT=np.zeros((Ne,4,4)) #Matriz de almacenamiento de las matrices de transformación\n",
    "for i in range(Ne):\n",
    "    MAT[i,0,0]=(MC[i][2]-MC[i][0])/(ML[i][0])\n",
    "    MAT[i,1,0]=(MC[i][3]-MC[i][1])/(ML[i][0])\n",
    "    MAT[i,2,2]=MAT[i,0,0]\n",
    "    MAT[i,3,2]=MAT[i,1,0]\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "*Visualización de la matriz de transformación de un elemento de la cercha:*\n",
    "\n",
    "Indique el número del elemento (n) para el cual desea ver la matriz de transformación.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.6</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.8</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0    1    2    3\n",
       "0  0.8  0.0  0.0  0.0\n",
       "1  0.6  0.0  0.0  0.0\n",
       "2  0.0  0.0  0.8  0.0\n",
       "3  0.0  0.0  0.6  0.0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.DataFrame(MAT[n])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de la matriz de rigidez de cada elemento en coordenadas globales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAG=np.zeros((Ne,4,4)) #Matriz de almacenamiento de las matrices de rigidez en coordenadas globales\n",
    "for i in range(Ne):\n",
    "    MAG[i]=np.dot(np.dot(MAT[i],MAL[i]),np.transpose(MAT[i]))  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "*Visualización de la matriz de rigidez global de un elemento de la cercha:*\n",
    "\n",
    "Indique el número del elemento (n) para el cual desea ver la matriz de rigidez global.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>19.2</td>\n",
       "      <td>14.4</td>\n",
       "      <td>-19.2</td>\n",
       "      <td>-14.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>14.4</td>\n",
       "      <td>10.8</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>-10.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>-19.2</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>19.2</td>\n",
       "      <td>14.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>-10.8</td>\n",
       "      <td>14.4</td>\n",
       "      <td>10.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      0     1     2     3\n",
       "0  19.2  14.4 -19.2 -14.4\n",
       "1  14.4  10.8 -14.4 -10.8\n",
       "2 -19.2 -14.4  19.2  14.4\n",
       "3 -14.4 -10.8  14.4  10.8"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.DataFrame(MAG[n])\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de la matriz de rigidez de la estructura:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "KG=np.zeros((NGL,NGL)) #Matriz de rigidez global de la estructura\n",
    "for i in range(Ne):\n",
    "    for j in range(4):\n",
    "        for k in range(4):\n",
    "            KG[int(MGL[i][k]),int(MGL[i][j])]=KG[int(MGL[i][k])][int(MGL[i][j])]+MAG[i][j][k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "      <th>5</th>\n",
       "      <th>6</th>\n",
       "      <th>7</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>100.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-50.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>0.0</td>\n",
       "      <td>50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>38.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-19.2</td>\n",
       "      <td>14.4</td>\n",
       "      <td>-19.2</td>\n",
       "      <td>-14.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>71.6</td>\n",
       "      <td>14.4</td>\n",
       "      <td>-10.8</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>-10.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>-50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-19.2</td>\n",
       "      <td>14.4</td>\n",
       "      <td>69.2</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>14.4</td>\n",
       "      <td>-10.8</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>10.8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>6</td>\n",
       "      <td>-50.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-19.2</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>69.2</td>\n",
       "      <td>14.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>7</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-14.4</td>\n",
       "      <td>-10.8</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>14.4</td>\n",
       "      <td>10.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       0     1     2     3     4     5     6     7\n",
       "0  100.0   0.0   0.0   0.0 -50.0   0.0 -50.0   0.0\n",
       "1    0.0  50.0   0.0 -50.0   0.0   0.0   0.0   0.0\n",
       "2    0.0   0.0  38.4   0.0 -19.2  14.4 -19.2 -14.4\n",
       "3    0.0 -50.0   0.0  71.6  14.4 -10.8 -14.4 -10.8\n",
       "4  -50.0   0.0 -19.2  14.4  69.2 -14.4   0.0   0.0\n",
       "5    0.0   0.0  14.4 -10.8 -14.4  10.8   0.0   0.0\n",
       "6  -50.0   0.0 -19.2 -14.4   0.0   0.0  69.2  14.4\n",
       "7    0.0   0.0 -14.4 -10.8   0.0   0.0  14.4  10.8"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df=pd.DataFrame(KG)\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Subdivisión de la matriz de rigidez global de la estructura:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "K0 = KG[0:NGLL,0:NGLL]\n",
    "K1 = KG[0:NGLL,NGLL:NGL]\n",
    "K2 = KG[NGLL:NGL,0:NGLL]\n",
    "K3 = KG[NGLL:NGL,NGLL:NGL]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de desplazamientos:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.53333333]\n",
      " [-1.37407407]\n",
      " [ 0.53333333]\n",
      " [-1.17407407]\n",
      " [ 1.06666667]]\n"
     ]
    }
   ],
   "source": [
    "Feff=F0-np.dot(K1,U1)\n",
    "U0=np.dot((np.linalg.inv(K0)),Feff) #Desplazamientos en los grados de libertad libres en mm    \n",
    "print(np.array(U0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de reacciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  5.]\n",
      " [-20.]\n",
      " [  5.]]\n"
     ]
    }
   ],
   "source": [
    "F1=np.dot(K2,U0)+np.dot(K3,U1) #Reacciones en kN (grados de libertad restringidos)\n",
    "print(np.array(F1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CÁLCULO DE LAS FUERZAS INTERNAS DE LA CERCHA:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: justify;'> En esta sección se calcula la fuerza interna de cada elemento de la cercha.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de las fuerzas de cada elemento en coodenadas globales:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "U=np.concatenate((U0,U1)) #Matriz de desplazamientos de todos los grados de libertad\n",
    "MU=np.zeros((Ne,4,1)) #Matriz de almacenamiento de vectores de desplazamiento de cada elemento\n",
    "for i in range(Ne):\n",
    "    for j in range(4):\n",
    "        MU[i,j,0]=U[int(MGL[i][j])][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "*Visualización de los desplazamientos de un elemento de la cercha:*\n",
    "\n",
    "Indique el número del elemento (n) para el cual desea ver los desplazamientos.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0.        ]\n",
      " [ 0.        ]\n",
      " [ 0.53333333]\n",
      " [-1.17407407]]\n"
     ]
    }
   ],
   "source": [
    "print(np.array(MU[n]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "MFG=np.zeros((Ne,4,1)) #Matriz de almacenamiento de las fuerzas de cada elemento en coordenadas globales\n",
    "for i in range(Ne):\n",
    "    MFG[i]=np.dot(MAG[i],MU[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "*Visualización de las fuerzas en coordenadas globales de un elemento de la cercha:*\n",
    "\n",
    "Indique el número del elemento (n) para el cual desea ver las fuerzas en coordenadas globales.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.66666667]\n",
      " [ 5.        ]\n",
      " [-6.66666667]\n",
      " [-5.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(np.array(MFG[n]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de las fuerzas de cada elemento en coordenadas locales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "MFL=np.zeros((Ne,4,1)) #Matriz de almacenamiento de las fuerzas de cada elemento en coordenadas locales\n",
    "for i in range(Ne):\n",
    "    MFL[i]=np.dot(np.transpose(MAT[i]),MFG[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">\n",
    "\n",
    "*Visualización de las fuerzas en coordenadas locales de un elemento de la cercha:*\n",
    "\n",
    "Indique el número del elemento (n) para el cual desea ver las fuerzas en coordenadas locales.\n",
    "\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "n=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8.33333333]\n",
      " [ 0.        ]\n",
      " [-8.33333333]\n",
      " [ 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(np.array(MFL[n]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cálculo de las fuerzas internas de cada elemento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-8.33333333]\n",
      " [-8.33333333]\n",
      " [26.66666667]\n",
      " [26.66666667]\n",
      " [10.        ]]\n"
     ]
    }
   ],
   "source": [
    "FELEM=np.zeros((Ne,1)) #Matriz de almacenamiento de fuerzas internas\n",
    "for i in range(Ne):\n",
    "    FELEM[i,0]=-MFL[i,0,0]\n",
    "print(np.array(FELEM))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}