Proyecto_3.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7f0577ca4c88>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib\n",
    "from matplotlib import cm\n",
    "import matplotlib.pyplot as plt\n",
    "import imageio\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "\n",
    "################### Parámetros a ingresar #######################\n",
    "\n",
    "# Nodos:\n",
    "Nx = 11  # Debe ser un número impar # 11 es el número mágico\n",
    "Ny = 16  # 16 es el número mágico\n",
    "# Convecciones:\n",
    "h1 = 5     #Aire\n",
    "h2 = 5   #Agua\n",
    "# Conducción:\n",
    "k = 50\n",
    "# Calor de entrada:\n",
    "q = 5e3/0.02\n",
    "\n",
    "\n",
    "Temperatura_interior = 700\n",
    "\n",
    "###################### NO TOCAR #################################\n",
    "\n",
    "dx = (15-5)/(Nx -1)\n",
    "dy = (20-5)/(Ny -1)\n",
    "\n",
    "\n",
    "\n",
    "x1 = np.arange(0,15+dx/2,dx)\n",
    "y1 = np.linspace(0,5,5/dy +1)\n",
    "\n",
    "\n",
    "\n",
    "x21 = np.linspace(5,15,Nx)\n",
    "y2 = np.linspace(5,20,Ny)\n",
    "y2 = y2[1:Ny-1]\n",
    "\n",
    "\n",
    "x3 = np.arange(0,15+dx/2,dx)\n",
    "y3 = np.linspace(20,25,(5/dy) +1)\n",
    "\n",
    "X1, Y1 = np.meshgrid(x1,y1)\n",
    "X2, Y2 = np.meshgrid(x2,y2)\n",
    "X3, Y3 = np.meshgrid(x3,y3)\n",
    "\n",
    "\n",
    "plt.figure(figsize=(10,10))\n",
    "\n",
    "\n",
    "plt.scatter(X3,Y3,label = 'Segmento Superior')\n",
    "plt.scatter(X1,Y1,label = 'Segmento inferior')\n",
    "plt.scatter(X2,Y2,label = 'Segmento medio')\n",
    "plt.title('Malla Geometría Primal',fontsize =22 )\n",
    "plt.xlabel('x [cm]',fontsize =22)\n",
    "plt.ylabel('y [cm]',fontsize =22)\n",
    "plt.grid()\n",
    "plt.legend(loc = 0)\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# ########################## Ubicación e identificación de Nodos ###############################\n",
    "\n",
    "# tamano_total = np.shape(X1)[0]*np.shape(X1)[1] + np.shape(X2)[0]*np.shape(X2)[1] + np.shape(X3)[0]*np.shape(X3)[1]\n",
    "\n",
    "\n",
    "# print('La Cantidad todal de Nodos en el sistema es de: ',tamano_total,' Nodos')\n",
    "# print('El espaciado entre nodos por la dirección x es: ',dx, 'cm')\n",
    "# print('El espaciado entre nodos por la dirección y es: ',dy, 'cm')\n",
    "\n",
    "# XY = np.zeros((tamano_total,2))\n",
    "# cto = 0\n",
    "# for i in range (0,np.shape(X1)[0]):\n",
    "#     for j in range(0,np.shape(X1)[1]):\n",
    "#         XY[cto][0] = X1[i][j]\n",
    "#         XY[cto][1] = Y1[i][j]\n",
    "#         cto = cto +1\n",
    "# for i in range (0,np.shape(X2)[0]):\n",
    "#     for j in range(0,np.shape(X2)[1]):\n",
    "#         XY[cto][0] = X2[i][j]\n",
    "#         XY[cto][1] = Y2[i][j]\n",
    "#         cto = cto + 1\n",
    "# for i in range (0,np.shape(X3)[0]):\n",
    "#     for j in range(0,np.shape(X3)[1]):\n",
    "#         XY[cto][0] = X3[i][j]\n",
    "#         XY[cto][1] = Y3[i][j]\n",
    "#         cto = cto + 1\n",
    "# h2 = 150\n",
    "# q = q*0.02\n",
    "\n",
    "# # Nodos interiores\n",
    "\n",
    "# zona1_e1 = np.where(XY[:,0]>0)\n",
    "# zona1_e11 = np.where(XY[zona1_e1][:,0]<5)\n",
    "# zona1_e111 = np.where(XY[zona1_e1[0][zona1_e11]][:,1]>20)\n",
    "# zona1_e1111 = np.where(XY[zona1_e1[0][zona1_e11][zona1_e111]][:,1]<25)\n",
    "# zona1_e1 = zona1_e1[0][zona1_e11][zona1_e111][zona1_e1111]\n",
    "\n",
    "\n",
    "# zona1_e2 = np.where(XY[:,0]>=5)\n",
    "# zona1_e22 = np.where(XY[zona1_e2][:,0]<15)\n",
    "# zona1_e222 = np.where(XY[zona1_e2[0][zona1_e22]][:,1]>=20)\n",
    "# zona1_e2222 = np.where(XY[zona1_e2[0][zona1_e22][zona1_e222]][:,1]<25)\n",
    "# zona1_e2 = zona1_e2[0][zona1_e22][zona1_e222][zona1_e2222]\n",
    "\n",
    "# zona2_e1 = np.where(XY[:,0]>5)\n",
    "# zona2_e11 = np.where(XY[zona2_e1][:,0]<15)\n",
    "# zona2_e111 = np.where(XY[zona2_e1[0][zona2_e11]][:,1]>5)\n",
    "# zona2_e1111 = np.where(XY[zona2_e1[0][zona2_e11][zona2_e111]][:,1]<20)\n",
    "# zona2_e1 = zona2_e1[0][zona2_e11][zona2_e111][zona2_e1111]\n",
    "\n",
    "# zona3_e1 = np.where(XY[:,0]>0)\n",
    "# zona3_e11 = np.where(XY[zona3_e1][:,0]<5)\n",
    "# zona3_e111 = np.where(XY[zona3_e1[0][zona3_e11]][:,1]>0)\n",
    "# zona3_e1111 = np.where(XY[zona3_e1[0][zona3_e11][zona3_e111]][:,1]<5)\n",
    "# zona3_e1 = zona3_e1[0][zona3_e11][zona3_e111][zona3_e1111]\n",
    "\n",
    "\n",
    "# zona3_e2 = np.where(XY[:,0]>=5)\n",
    "# zona3_e22 = np.where(XY[zona3_e2][:,0]<15)\n",
    "# zona3_e222 = np.where(XY[zona3_e2[0][zona3_e22]][:,1]>0)\n",
    "# zona3_e2222 = np.where(XY[zona3_e2[0][zona3_e22][zona3_e222]][:,1]<=5)\n",
    "# zona3_e2 = zona3_e2[0][zona3_e22][zona3_e222][zona3_e2222]\n",
    "\n",
    "# interiores = np.concatenate((zona1_e1,zona1_e2,zona2_e1,zona3_e1,zona3_e2))\n",
    "\n",
    "# # Nodos frontera\n",
    "\n",
    "# Frontera_este = np.where(XY[:,0]==15)\n",
    "# Frontera_este2 = np.where(XY[Frontera_este][:,1]>0)\n",
    "# Frontera_este22 = np.where(XY[Frontera_este[0][Frontera_este2]][:,1]<25)\n",
    "# Frontera_este = Frontera_este[0][Frontera_este2][Frontera_este22]\n",
    "\n",
    "# Frontera_oeste = np.where(XY[:,0]==0)\n",
    "# Frontera_oeste2 = np.where(XY[Frontera_oeste][:,1]>0)\n",
    "# Frontera_oeste22 = np.where(XY[Frontera_oeste[0][Frontera_oeste2]][:,1]<25)\n",
    "# Frontera_oeste222 = np.where(XY[Frontera_oeste[0][Frontera_oeste2][Frontera_oeste22]][:,1]<5)\n",
    "# Frontera_oeste2222 = np.where(XY[Frontera_oeste[0][Frontera_oeste2][Frontera_oeste22]][:,1]>20)\n",
    "# Frontera_oeste1 = np.where(XY[:,0] == 5)\n",
    "# Frontera_oeste11 = np.where(XY[Frontera_oeste1][:,1]>5)\n",
    "# Frontera_oeste111 = np.where(XY[Frontera_oeste1[0][Frontera_oeste11]][:,1]<20)\n",
    "# Frontera_oeste_cond1 = np.concatenate((Frontera_oeste[0][Frontera_oeste2][Frontera_oeste22][Frontera_oeste222],Frontera_oeste[0][Frontera_oeste2][Frontera_oeste22][Frontera_oeste2222]),axis=0)\n",
    "# Frontera_oeste_cond2 = Frontera_oeste1[0][Frontera_oeste11][Frontera_oeste111]\n",
    "# Frontera_oeste = np.concatenate((Frontera_oeste[0][Frontera_oeste2][Frontera_oeste22][Frontera_oeste222],Frontera_oeste[0][Frontera_oeste2][Frontera_oeste22][Frontera_oeste2222],Frontera_oeste1[0][Frontera_oeste11][Frontera_oeste111]),axis = 0)\n",
    "\n",
    "\n",
    "# Frontera_Norte = np.where(XY[:,1]==25)\n",
    "# Frontera_Norte2 = np.where(XY[Frontera_Norte][:,0]>0) \n",
    "# Frontera_Norte22 = np.where(XY[Frontera_Norte[0][Frontera_Norte2]][:,0]<15) \n",
    "# Frontera_Norte1 = np.where(XY[:,1] == 5)\n",
    "# Frontera_Norte11 = np.where(XY[Frontera_Norte1][:,0]< 5)\n",
    "# Frontera_Norte111 = np.where(XY[Frontera_Norte1[0][Frontera_Norte11]][:,0]>0)\n",
    "# Frontera_Norte_cond1 = Frontera_Norte[0][Frontera_Norte2][Frontera_Norte22]\n",
    "# Frontera_Norte_cond2 = Frontera_Norte1[0][Frontera_Norte11][Frontera_Norte111]\n",
    "# Frontera_Norte = np.concatenate((Frontera_Norte[0][Frontera_Norte2][Frontera_Norte22],Frontera_Norte1[0][Frontera_Norte11][Frontera_Norte111]),axis = 0)\n",
    "\n",
    "\n",
    "# Frontera_sur = np.where(XY[:,1]==0)\n",
    "# Frontera_sur2 = np.where(XY[Frontera_sur][:,0]>0) \n",
    "# Frontera_sur22 = np.where(XY[Frontera_sur[0][Frontera_sur2]][:,0]<15) \n",
    "# Frontera_sur1 = np.where(XY[:,1] == 20)\n",
    "# Frontera_sur11 = np.where(XY[Frontera_sur1][:,0]< 5)\n",
    "# Frontera_sur111 = np.where(XY[Frontera_sur1[0][Frontera_sur11]][:,0]>0)\n",
    "# Frontera_sur_cond1 = Frontera_sur[0][Frontera_sur2][Frontera_sur22]\n",
    "# Frontera_sur_cond2 = Frontera_sur1[0][Frontera_sur11][Frontera_sur111]\n",
    "# Frontera_sur = np.concatenate((Frontera_sur[0][Frontera_sur2][Frontera_sur22],Frontera_sur1[0][Frontera_sur11][Frontera_sur111]),axis = 0)\n",
    "\n",
    "\n",
    "# Frontera = np.concatenate((Frontera_este,Frontera_oeste,Frontera_Norte,Frontera_sur))\n",
    "# # Nodos esquina\n",
    "\n",
    "# Esquina_North_East = np.where(XY[:,0]==15)\n",
    "# Esquina_North_East1 = np.where(XY[Esquina_North_East[0]][:,1]==25)\n",
    "# Esquina_North_East = Esquina_North_East[0][Esquina_North_East1]\n",
    "\n",
    "# Esquina_North_West = np.where(XY[:,0]==0)\n",
    "# Esquina_North_West1 = np.where(XY[Esquina_North_West[0]][:,1]==25)\n",
    "# Esquina_North_West = Esquina_North_West[0][Esquina_North_West1]\n",
    "\n",
    "# Esquina_South_East = np.where(XY[:,0]==15)\n",
    "# Esquina_South_East1 = np.where(XY[Esquina_South_East[0]][:,1]==0)\n",
    "# Esquina_South_East = Esquina_South_East[0][Esquina_South_East1]\n",
    "\n",
    "# Esquina_South_West = np.where(XY[:,0]==0)\n",
    "# Esquina_South_West1 = np.where(XY[Esquina_South_West[0]][:,1]==0)\n",
    "# Esquina_South_West = Esquina_South_West[0][Esquina_South_West1]\n",
    "\n",
    "# Esquina_West_up = np.where(XY[:,0] == 0)\n",
    "# Esquina_West_up1 = np.where(XY[Esquina_West_up][:,1] == 5)\n",
    "# Esquina_West_up = Esquina_West_up[0][Esquina_West_up1]\n",
    "\n",
    "# Esquina_West_down = np.where(XY[:,0] == 0)\n",
    "# Esquina_West_down1 = np.where(XY[Esquina_West_down][:,1] == 20)\n",
    "# Esquina_West_down = Esquina_West_down[0][Esquina_West_down1]\n",
    "\n",
    "# Esquinas = np.concatenate((Esquina_North_East,Esquina_North_West,Esquina_South_East,Esquina_South_West))\n",
    "\n",
    "# plt.figure(figsize = (15,15))\n",
    "# plt.subplot(2,2,1)\n",
    "# plt.scatter(XY[:,0],XY[:,1])\n",
    "# plt.title('Sistema completo')\n",
    "# plt.subplot(2,2,2)\n",
    "# plt.scatter(XY[zona1_e1][:,0],XY[zona1_e1][:,1])\n",
    "# plt.scatter(XY[zona1_e2][:,0],XY[zona1_e2][:,1])\n",
    "# plt.scatter(XY[zona2_e1][:,0],XY[zona2_e1][:,1])\n",
    "# plt.scatter(XY[zona3_e1][:,0],XY[zona3_e1][:,1])\n",
    "# plt.scatter(XY[zona3_e2][:,0],XY[zona3_e2][:,1])\n",
    "# plt.grid()\n",
    "# plt.title('Nodos interiores')\n",
    "# plt.subplot(2,2,3)\n",
    "# plt.scatter(XY[Frontera_sur][:,0],XY[Frontera_sur][:,1])\n",
    "# plt.scatter(XY[Frontera_Norte][:,0],XY[Frontera_Norte][:,1])\n",
    "# plt.scatter(XY[Frontera_oeste][:,0],XY[Frontera_oeste][:,1])\n",
    "# plt.scatter(XY[Frontera_este][:,0],XY[Frontera_este][:,1])\n",
    "# plt.grid()\n",
    "# plt.title('Nodos Frontera')\n",
    "# plt.subplot(2,2,4)\n",
    "# plt.scatter(XY[Esquina_North_East][:,0],XY[Esquina_North_East][:,1])\n",
    "# plt.scatter(XY[Esquina_North_West][:,0],XY[Esquina_North_West][:,1])\n",
    "# plt.scatter(XY[Esquina_South_East][:,0],XY[Esquina_South_East][:,1])\n",
    "# plt.scatter(XY[Esquina_South_West][:,0],XY[Esquina_South_West][:,1])\n",
    "# plt.scatter(XY[Esquina_West_down][:,0],XY[Esquina_West_down][:,1])\n",
    "# plt.scatter(XY[Esquina_West_up][:,0],XY[Esquina_West_up][:,1])\n",
    "# plt.grid()\n",
    "# plt.title('Nodos Esquina')\n",
    "\n",
    "\n",
    "# ######################################## Matriz a invertir ###################################\n",
    "\n",
    "# # iniciamos con la matriz a invertir \n",
    "\n",
    "# Juno = np.zeros((tamano_total,tamano_total))\n",
    "# Ceres = np.zeros((tamano_total,1))\n",
    "\n",
    "# # Empezamos a llenarla \n",
    "# # Interiores\n",
    "# for i in interiores:\n",
    "#     Juno[i,i] = -2/(dx**2) -2/(dy**2)\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx**2)\n",
    "#     Juno[i,izquierda] = 1/(dx**2)\n",
    "#     Juno[i,arriba] = 1/(dy**2)\n",
    "#     Juno[i,abajo] = 1/(dy**2)\n",
    "    \n",
    "# # Forntera Este\n",
    "# for i in Frontera_este:\n",
    "#     Juno[i,i] = -2/dy -2/dx - 2*h2/k\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,izquierda] = 2/(dx)\n",
    "#     Juno[i,arriba] = 1/(dy)\n",
    "#     Juno[i,abajo] = 1/(dy)\n",
    "    \n",
    "# # Frontera Oeste  \n",
    "# for i in Frontera_oeste_cond1:\n",
    "#     Juno[i,i] = -2/dy -2/dx\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 2/(dx)\n",
    "#     Juno[i,arriba] = 1/(dy)\n",
    "#     Juno[i,abajo] = 1/(dy)\n",
    "    \n",
    "# for i in Frontera_oeste_cond2:\n",
    "#     Juno[i,i] = -2/dy -2/dx\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 2/(dx)\n",
    "#     Juno[i,arriba] = 1/(dy)\n",
    "#     Juno[i,abajo] = 1/(dy)\n",
    "    \n",
    "# # Frontera Norte\n",
    "# for i in Frontera_Norte_cond1:\n",
    "#     Juno[i,i] = -2/dy -2/dx -2*h1/k\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,izquierda] = 1/(dx)\n",
    "#     Juno[i,abajo] = 2/(dy)\n",
    "    \n",
    "# for i in Frontera_Norte_cond2:\n",
    "#     Juno[i,i] = -2/dy -2/dx\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,izquierda] = 1/(dx)\n",
    "#     Juno[i,abajo] = 2/(dy)\n",
    "\n",
    "# # Frontera sur\n",
    "# for i in Frontera_sur_cond1:\n",
    "#     Juno[i,i] = -2/dy -2/dx -2*h1/k\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,izquierda] = 1/(dx)\n",
    "#     Juno[i,arriba] = 2/(dy)\n",
    "    \n",
    "# for i in Frontera_sur_cond2:\n",
    "#     Juno[i,i] = -2/dy -2/dx\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,izquierda] = 1/(dx)\n",
    "#     Juno[i,arriba] = 2/(dy)\n",
    "\n",
    "# #Esquinas\n",
    "\n",
    "# # North-East\n",
    "# for i in Esquina_North_East:\n",
    "#     Juno[i,i] = -1/dy -1/dx - 2*h2/k -2*h1/k\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,izquierda] = 1/(dx)\n",
    "#     Juno[i,abajo] = 1/(dy)\n",
    "    \n",
    "# # South-East\n",
    "# for i in Esquina_South_East:\n",
    "#     Juno[i,i] = -1/dy -1/dx - 2*h2/k -2*h1/k\n",
    "    \n",
    "#     izquierda = np.where(XY[:,0] == XY[i,0]-dx)\n",
    "#     izquierda_1 = np.where(XY[izquierda[0]][:,1] == XY[i,1])\n",
    "#     izquierda = izquierda[0][izquierda_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     Juno[i,izquierda] = 1/(dx)\n",
    "#     Juno[i,arriba] = 1/(dy)\n",
    "\n",
    "# # North-West\n",
    "# for i in Esquina_North_West:\n",
    "#     Juno[i,i] = -1/dy -1/dx -2*h1/k\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,abajo] = 1/(dy)\n",
    "    \n",
    "# # South-West\n",
    "# for i in Esquina_South_West:\n",
    "#     Juno[i,i] = -1/dy -1/dx -2*h1/k\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,arriba] = 1/(dy)\n",
    "    \n",
    "# # West_Down\n",
    "# for i in Esquina_West_down:\n",
    "#     Juno[i,i] = -1/dy -1/dx\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     abajo = np.where(XY[:,1] == XY[i,1]-dx)\n",
    "#     abajo_1 = np.where(XY[abajo[0]][:,0] == XY[i,0])\n",
    "#     abajo = abajo[0][abajo_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,abajo] = 1/(dy)\n",
    "\n",
    "# # West_Up\n",
    "# for i in Esquina_West_up:\n",
    "#     Juno[i,i] = -1/dy -1/dx\n",
    "    \n",
    "#     derecha = np.where(XY[:,0] == XY[i,0]+dx)\n",
    "#     derecha_1 = np.where(XY[derecha[0]][:,1] == XY[i,1])\n",
    "#     derecha = derecha[0][derecha_1]\n",
    "    \n",
    "#     arriba = np.where(XY[:,1] == XY[i,1]+dx)\n",
    "#     arriba_1 = np.where(XY[arriba[0]][:,0] == XY[i,0])\n",
    "#     arriba = arriba[0][arriba_1]\n",
    "    \n",
    "#     Juno[i,derecha] = 1/(dx)\n",
    "#     Juno[i,arriba] = 1/(dy)\n",
    "    \n",
    "\n",
    "\n",
    "# ############################### Vector Ceres ##############################\n",
    "\n",
    "# # Empezamos a llenar el vector Ceres\n",
    "\n",
    "# for i in Frontera_oeste_cond2:\n",
    "#     Ceres[i] = q*2/k\n",
    "    \n",
    "# for i in Frontera_Norte_cond2:\n",
    "#     Ceres[i] = q*2/k\n",
    "    \n",
    "# for i in Frontera_sur_cond2:\n",
    "#     Ceres[i] = q*2/k\n",
    "    \n",
    "# for i in Esquina_West_down:\n",
    "#     Ceres[i] = q*2/k\n",
    "    \n",
    "# for i in Esquina_West_up:\n",
    "#     Ceres[i] = q*2/k\n",
    "    \n",
    "# ############################### Invertir la matriz y multiplicar #############\n",
    "\n",
    "# Temp = -np.dot(np.linalg.inv(Juno),Ceres)\n",
    "\n",
    "\n",
    "# ###################### Reorganización y resultados ################\n",
    "\n",
    "# X1_Temp = np.zeros((np.shape(X1)[0],np.shape(X1)[1]))\n",
    "# X2_Temp = np.zeros((np.shape(X2)[0],np.shape(X2)[1]))\n",
    "# X3_Temp = np.zeros((np.shape(X3)[0],np.shape(X3)[1]))\n",
    "\n",
    "# cto = 0\n",
    "# for i in range (0,np.shape(X1)[0]):\n",
    "#     for j in range(0,np.shape(X1)[1]):\n",
    "#         X1_Temp[i][j] = Temp[cto] \n",
    "#         cto = cto +1\n",
    "# for i in range (0,np.shape(X2)[0]):\n",
    "#     for j in range(0,np.shape(X2)[1]):\n",
    "#         X2_Temp[i][j] = Temp[cto]\n",
    "#         cto = cto + 1\n",
    "# for i in range (0,np.shape(X3)[0]):\n",
    "#     for j in range(0,np.shape(X3)[1]):\n",
    "#         X3_Temp[i][j] = Temp[cto]\n",
    "#         cto = cto + 1\n",
    "        \n",
    "        \n",
    "# fig, ax = plt.subplots(figsize=(10,10))\n",
    "# ax = fig.add_subplot(1,1,1,projection='3d')\n",
    "# ax.plot_surface(X1, Y1, X1_Temp, cmap=cm.coolwarm, linewidth=0, antialiased=False)\n",
    "# ax.plot_surface(X2, Y2, X2_Temp, cmap=cm.coolwarm, linewidth=0, antialiased=False)\n",
    "# ax.plot_surface(X3, Y3, X3_Temp, cmap=cm.coolwarm, linewidth=0, antialiased=False)\n",
    "# plt.title('Sistema Térmico',fontsize = 22)\n",
    "# plt.xlabel('X [cm]',fontsize=15)\n",
    "# plt.ylabel('Y [cm]',fontsize=15)\n",
    "# ax.set_zlabel('T [°C]',fontsize=15)\n",
    "# plt.savefig('Prefil_temp.png')\n",
    "\n",
    "# plt.figure(figsize = (10,10))\n",
    "# plt.contourf(X1, Y1, X1_Temp,cmap=cm.coolwarm)\n",
    "# plt.contourf(X2, Y2, X2_Temp,cmap=cm.coolwarm)\n",
    "# plt.contourf(X3, Y3, X3_Temp,cmap=cm.coolwarm)\n",
    "# plt.savefig('contorno_temp.png')\n",
    "# plt.colorbar()\n"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}