diff --git a/Explicaciones_cod.ipynb b/Explicaciones_cod.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..f2d4c3da37e1f9b955f068b72049bf993f682dd6
--- /dev/null
+++ b/Explicaciones_cod.ipynb
@@ -0,0 +1,660 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Monte Carlo cinético para un sistema de reacción-difusión unidimensional\n",
+ "\n",
+ "### Proyecto de Datos\n",
+ "\n",
+ "**Presentado por:** Sasiri Juliana Vargas Urbano (@vargass)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import random as rm\n",
+ "import numpy as np\n",
+ "import matplotlib\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "from matplotlib.animation import FuncAnimation #Para las animaciones\n",
+ "import moviepy.editor as mp #Para transformar el gif en mp4\n",
+ "from IPython.display import Video #Para reproducir el video mp4 notebook"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "### Algunas cantidades y definiciones que se utilizarán para el código son:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Para la discretización**<br>\n",
+ "$\\Delta x = 1$ : Paso espacial <br>\n",
+ "$\\Delta t = 1$ : Paso temporal\n",
+ "\n",
+ "**Constante de reacción**<br>\n",
+ "K : _La define el usuario_\n",
+ "\n",
+ "**Tasa de reacción**<br>\n",
+ "$\\beta= K/\\Delta x$\n",
+ "\n",
+ "**Coeficiente de difusión**<br>\n",
+ "D : _La define el usuario_\n",
+ "\n",
+ "**Tasa de salto**<br>\n",
+ "$\\lambda = D/\\Delta x^2$\n",
+ "\n",
+ "**Probabilidad de salto**<br>\n",
+ "$P_S = \\lambda \\: \\Delta t$\n",
+ "\n",
+ "**Corriente de incersion**<br>\n",
+ "j : _La define el usuario_\n",
+ "\n",
+ "**Probabilidad de incersion**<br>\n",
+ "$P_J= j$\n",
+ "\n",
+ "**Probabilidad de reacción**<br>\n",
+ "$P_R= \\beta \\Delta t$"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Densidad local (discreta):** (Aplica tanto para partÃculas A como partÃculas B)<br>\n",
+ "$\\rho_i (t)$: _Es lo que va a evolucionar en la simulación_\n",
+ "\n",
+ "**Densidad local (continua):** (Aplica tanto para partÃculas A como partÃculas B)<br>\n",
+ "$\\rho (x) = <\\rho_i (t)>$<br>\n",
+ "Donde < > representa el promedio sobre configuraciones y $\\rho_i (t)$ es el número de partÃculas en el sitio i.\n",
+ "\n",
+ "**Posición de la partÃcula A ubicada más a la derecha**<br>\n",
+ "$RMA$ : _Se determina en la simulación_\n",
+ "\n",
+ "**Posición de la partÃcula B ubicada más a la izquierda**<br>\n",
+ "$LMB$ : _Se determina en la simulación_\n",
+ "\n",
+ "**Distribución de espaciamientos (discreta):**<br>\n",
+ "$P_i(t) = \\left\\lbrace\n",
+ "\\begin{array}{ll}\n",
+ " 1 & {si \\; en \\; t} \\:|RMA-LMB|= i \\\\\n",
+ "0 & {de \\; otra \\; forma} \n",
+ "\\end{array}\n",
+ "\\right.$\n",
+ "\n",
+ "**Distribución de espaciamientos (continua):**<br>\n",
+ "$P(x,t)$ = < $P_i(t)$ > / $\\Delta x$ <br>\n",
+ "Donde < > representa el promedio sobre configuraciones"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Código (Escritura de archivos y gráficas)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Para 1 Experimento:**<br>\n",
+ "Para la escritura del código se utilizan 2 funciones principales:<br>\n",
+ "- *Dinamica* : Contiene el código que evoluciona el sistema en un paso de tiempo. Los parámetros de esta función son:\n",
+ "\n",
+ " - vec : arreglo a evolucionar\n",
+ " - l : 1/2 de la longitud del arreglo (fÃsicamente 1/2 de la longitud del sistema)\n",
+ " - Pr : Probabilidad de reaccion impuesta por el usuario\n",
+ " - Pj : Probabilidad de incersion impuesta por el usuario\n",
+ " - Ps : Probabilidad de salto impuesta por el usuario\n",
+ "\n",
+ "- *ciclos* : Realiza la función dinámica en N pasos de tiempo. Los parámetros de esta función son:\n",
+ " - c_ini : condición inicial\n",
+ " - l : Longitud del arreglo (fÃsicamente la longitud del sistema)\n",
+ " - Pr : Probabilidad de reaccion impuesta por el usuario\n",
+ " - Pj : Probabilidad de incersion impuesta por el usuario\n",
+ " - Ps : Probabilidad de salto impuesta por el usuario\n",
+ " - time :tiempo de la simulación\n",
+ "\n",
+ "\n",
+ "**Funciones adicionales:**<br>\n",
+ "También se hace uso de funciones adicionales de utilidad:\n",
+ "\n",
+ "- *P_i* : Definición de la distribución de espaciamiento discreta para una distancia i<br>\n",
+ " - r : Para insertar la variable RMA\n",
+ " - l : Para insertar la variable LMB\n",
+ " - i : distancia a evaluar\n",
+ " \n",
+ "- *P_i_xt* : Distribución de espaciamiento discreta evaluando para 0<i<2L<br>\n",
+ " - r_ : Para insertar la variable RMA\n",
+ " - l_ : Para insertar la variable LMB\n",
+ " - L_ : 1/2 Longitud del sistema\n",
+ "\n",
+ "- *concentracionA_B* : Separa el arreglo ingresado, obteniendo 2 arreglos, para almacenar separadamente la información de las partÃculas A y B\n",
+ " - entrada : arreglo a separar\n",
+ "\n",
+ "\n",
+ "**Función total (M experimentos):**<br>\n",
+ "Finalmente, ya que se trata de un Monte Carlo, se deben hacer múltiples repeticiones del experimento. Para ello se hace uso de un ciclo for dentro de la función 'ANALISIS' (+).\n",
+ "\n",
+ "Los parámetros de esta función son (se igualan a valores por defecto):\n",
+ "\n",
+ "- L=5 : Longitud del sistema\n",
+ "- dx=1 : Espaciamiento espacial\n",
+ "- dt=1 : Espaciamiento temporal\n",
+ "- D=0.5 : Coeficiente de difusión (tiene información del salto de las partÃculas)\n",
+ "- j=1 : Corriente de incerción (tiene información sobre la incerción de partÃculas)\n",
+ "- K=1 : Constante de reacción (tiene información sobre la reacción de las partÃculas)\n",
+ "- tiempo=2000 : Tiempo de simulación (Se espera que este sea el tiempo para llegar al estado estacionario)\n",
+ "- rep=10 : Cantidad de repeticiones del experimento\n",
+ "- opcion='datos' : (ver abajo+)\n",
+ "- nombre = 'Data': 'Prefijo' que se le dará a los archivos que guardan la información de la simulación.\n",
+ "\n",
+ "\n",
+ "(+) La función ANALISIS tiene tres opciones: \n",
+ "- 'datos' : Crea 3 archivos en los que se tiene la información de la distribución de espacimiento, la información de las concentraciones de A y de B, después de hacer varias repeticiones del experimento. También presenta las gráficas de la distribución de espaciamientos y los perfiles de concentraciones de A y B.\n",
+ "\n",
+ "- 'dinamica' : Permite visualizar lo que ocurre en el sistema, imprimiendo el vector que representa el sistema en cada paso de tiempo.\n",
+ "\n",
+ "- 'estacionario' : Evalúa si el tiempo ingresado lleva al estado a su estado estacionario\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "**Funciones:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#------------\n",
+ "# DINÃMICA\n",
+ "#------------\n",
+ "def Dinamica(vec, l, Pr, Pj, Ps):\n",
+ "\n",
+ " #Vector que almacena las concentraciones de las partÃculas A y B\n",
+ " concentracion=np.array(vec)\n",
+ " #Vector que almacena la distribución de espaciamientos\n",
+ " Pesp=np.zeros(len(concentracion)) \n",
+ "\n",
+ " # Números aleatorios:\n",
+ " #--------------------\n",
+ "\n",
+ " #Se tienen 4 números aleatorios. 3 de ellos representan la posibilidad de tener o no,\n",
+ " #reacción, incerción y salto. El restante es el sitio en el que ocurrirá la dinámica\n",
+ "\n",
+ " Escogida = rm.randint(0,2*l) #Num aleatorio que escoge el sitio de red para efectuar la dinpamica\n",
+ " particula = concentracion[Escogida] #Tipo de partÃcula escogida\n",
+ "\n",
+ " p_r = rm.uniform(0,1e7)/1e7 #Num aleatorio para la prob de reacción\n",
+ " p_j = rm.uniform(0,1e7)/1e7 #Num aleatorio para la prob de incerción\n",
+ " p_s = rm.uniform(0,1e7)/1e7 #Num aleatorio para la prob de salto\n",
+ "\n",
+ "\n",
+ " # Saltos\n",
+ " # -------\n",
+ "\n",
+ " #Para los saltos se tiene en cuenta lo siguiente:\n",
+ " #Si 0 < p_s < Ps -> ocurre un salto hacia la derecha\n",
+ " #Si Ps < p_s < 2*Ps -> ocurre un salto hacia la izquierda\n",
+ " #(Siempre y cuando el sitio al que saltará la partÃcula este vacÃo)\n",
+ " #Esto se realiza para que podamos tener información tanto de la posibilidad de salto,\n",
+ " #como de la posibilidad de no saltar\n",
+ "\n",
+ " #Ejemplo: Si Ps=0.5, entonces:\n",
+ " #Salto a la derecha : 0 < p_s < 0.5 --> 50% de las veces \n",
+ " #Salto a la izquierda: 0.5 < p_s < 1 --> 50% de las veces\n",
+ " #No salta --> 0% de las veces\n",
+ "\n",
+ " if p_s < 2*Ps:\n",
+ "\n",
+ " #Salto general (Se pueden escoger todos los sitios, excepto los extremos)\n",
+ " if all((Escogida != 0, Escogida != 2*l, concentracion[Escogida] != 0)):\n",
+ " #Salto derecha\n",
+ " if all((p_s < Ps, concentracion[Escogida + 1] == 0)):\n",
+ " concentracion[Escogida + 1] = particula\n",
+ " concentracion[Escogida] = 0\n",
+ " #Salto izquierda\n",
+ " elif all((Ps < p_s < 2*Ps, concentracion[Escogida - 1] == 0)):\n",
+ " concentracion[Escogida - 1] = particula\n",
+ " concentracion[Escogida] = 0\n",
+ "\n",
+ " #Extremo izquierdo (dominio de la partÃcula A) \n",
+ " elif Escogida == 0:\n",
+ " #Incercion: Si p_j < Pj, entonces se efectúa la incerción\n",
+ " if all((p_j < Pj, concentracion[Escogida] == 0)):\n",
+ " concentracion[Escogida] = -1\n",
+ " #Salto: Se considera que hay salto a la derecha\n",
+ " elif all((p_s < Ps, concentracion[0] != 0, concentracion[1] == 0)):\n",
+ " concentracion[1] = particula\n",
+ " concentracion[0] = 0\n",
+ "\n",
+ " #Extremo derecho (dominio de la partÃcula B)\n",
+ " elif Escogida == 2*l:\n",
+ " #Incersion: Si p_j < Pj, entonces se efectúa la incerción\n",
+ " if all((p_j < Pj, concentracion[Escogida] == 0)):\n",
+ " concentracion[Escogida] = 1\n",
+ " #Salto: Se considera que hay salto a la izquierda\n",
+ " elif all((p_s < Ps, concentracion[2*l] != 0, concentracion[2*l-1] == 0)):\n",
+ " concentracion[2*l-1] = particula\n",
+ " concentracion[2*l] = 0\n",
+ "\n",
+ " # Reaccion\n",
+ " #----------\n",
+ "\n",
+ " #La reacción se efectúa si p_r < Pr y si la distancia entre rma y lmb es igual a 1 (si A y B son vecinos)\n",
+ "\n",
+ " try: \n",
+ " #El try y el except es puesto porque hay ocasiones en las que se tiene por ejemplo:\n",
+ " #[-1,-1,-1,0,0,0]\n",
+ " #Entonces en este caso no es posible encontrar un lmb\n",
+ "\n",
+ " #rma\n",
+ " where1=np.where(concentracion == -1) #devuelve una tupla\n",
+ " rmav=where1[0] #Arreglo de las ubicaciones de las partÃculas A\n",
+ " rma=rmav[-1] #PartÃcula más a la derecha\n",
+ "\n",
+ " #lmb\n",
+ " where2=np.where(concentracion == 1) \n",
+ " lmbv=where2[0] #Arreglo de las ubicaciones de las partÃculas B\n",
+ " lmb=lmbv[0] #PartÃcula más a la izquierda\n",
+ "\n",
+ " if (p_r < Pr) and (abs(rma-lmb) == 1): #Las partÃculas se aniquilan\n",
+ " concentracion[rma] = 0 \n",
+ " concentracion[lmb] = 0\n",
+ "\n",
+ " #Se encuentran los nuevos rma y lmb para encontrar la distr. de espaciamientos\n",
+ " #rma\n",
+ " where1=np.where(concentracion == -1)\n",
+ " rmav=where1[0]\n",
+ " rma=rmav[-1]\n",
+ "\n",
+ " #lmb\n",
+ " where2=np.where(concentracion == 1)\n",
+ " lmbv=where2[0]\n",
+ " lmb=lmbv[0]\n",
+ "\n",
+ " #Función que devuelve un arreglo de la distribución de espaciamientos\n",
+ " Pesp= P_i_xt(rma,lmb,l)\n",
+ "\n",
+ " except: \n",
+ " pass\n",
+ "\n",
+ " return concentracion, Pesp # Devuelve 2 arreglos"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# ---------\n",
+ "# CICLOS\n",
+ "# ---------\n",
+ "\n",
+ "#Repite la función 'Dinamica' una cantidad M de veces, determinada por 'time'\n",
+ "\n",
+ "def ciclos(c_ini, l, Pr, Pj, Ps, time):\n",
+ "\n",
+ " resultado=np.copy(c_ini) # copia de la condición inicial\n",
+ " salida_conc_A=np.zeros(len(resultado)) # arreglo de salida para la concentración de A\n",
+ " salida_conc_B=np.zeros(len(resultado)) # arreglo de salida para la concentración de B\n",
+ " salida_esp=np.zeros(len(resultado)) # arreglo de salida para la dist. de espaciamientos\n",
+ "\n",
+ " for i in range(time+1):\n",
+ " resultado, espaciamiento = Dinamica(resultado, l, Pr, Pj, Ps) #Dinamica para el tiempo i\n",
+ " A, B = concentracionA_B(resultado) # Separación de arreglos\n",
+ "\n",
+ " return A, B, espaciamiento # Devuelve 3 arreglos"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#------------------------\n",
+ "# FUNCIONES ADICIONALES\n",
+ "#------------------------\n",
+ "\n",
+ "#------------------------------------------\n",
+ "# Distribución de espaciamientos discreta\n",
+ "#------------------------------------------\n",
+ "\n",
+ "#La distribución de espaciamiento discreta se encuentra con la función P_i_xt(r_,l_,L_),\n",
+ "#la cual utiliza P_i(r,l,i).\n",
+ "\n",
+ "#Devuelve un arreglo por ejemplo: [0,0,1,0,0,0]\n",
+ "#Indicando que la distancia entre rma y lmb es 2\n",
+ "\n",
+ "def P_i(r,l,i):\n",
+ " salida=0\n",
+ " if (abs(r-l)==i):\n",
+ " salida=1\n",
+ " return salida\n",
+ "\n",
+ "def P_i_xt(r_,l_,L_):\n",
+ " return [P_i(r_,l_,j) for j in range(2*L_+1)]\n",
+ "\n",
+ "\n",
+ "#------------------------------------\n",
+ "# Separación de concentraciones\n",
+ "#------------------------------------\n",
+ "\n",
+ "#Entra un arreglo del tipo: [-1,-1, 0, 1, 1]\n",
+ "# Y devuelve dos arreglos: [ 1, 1, 0, 0, 0] --> Para las partÃculas A \n",
+ "# [ 0, 0, 0, 1, 1] --> Para las partÃculas B\n",
+ "\n",
+ "def concentracionA_B(entrada):\n",
+ " salida_A = np.zeros(len(entrada))\n",
+ " salida_B = np.zeros(len(entrada))\n",
+ "\n",
+ " for i in range(len(entrada)):\n",
+ "\n",
+ " if entrada[i] == -1:\n",
+ " salida_A[i] = 1\n",
+ "\n",
+ " elif entrada[i] == 1:\n",
+ " salida_B[i] = 1\n",
+ "\n",
+ " return salida_A, salida_B"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#--------------\n",
+ "# ANALISIS\n",
+ "#--------------\n",
+ "def ANALISIS(L=5, dx=1, dt=1, D=0.5, j=1, K=1, tiempo=2000, rep=10, opcion='datos', nombre = 'Data'):\n",
+ " \n",
+ " #PARÃMETROS\n",
+ " \n",
+ " beta= K/dx # Tasa de reacción\n",
+ " lamb = D/dx**2 #Tasa de salto\n",
+ " P_S = lamb * dt # Probabilidad de salto\n",
+ " P_J= j #Probabilidad de incersion\n",
+ " P_R= beta*dt #Probabilidad de reacción\n",
+ " \n",
+ " #CONDICION INICIAL\n",
+ " \n",
+ " # 0 : VacÃo \n",
+ " # -1 : PartÃcula A\n",
+ " # 1 : Particula B \n",
+ " \n",
+ " condicion_inicial=[-1 if i<L else 1 for i in range(2*L+1)] #Ilustracion para L=3: [-1,-1,-1,1,1,1]\n",
+ "\n",
+ "#-----------------------------------OPCIONES------------------------------------\n",
+ " \n",
+ " if opcion=='graficos':\n",
+ "\n",
+ " x = np.linspace(-L, L, 2*L+1) #Posiciones\n",
+ " z = np.linspace(0, 2*L, 2*L+1) #Distancias dist. de espaciamientos\n",
+ "\n",
+ " salida_A=np.zeros(len(x))\n",
+ " salida_B=np.zeros(len(x))\n",
+ " salida_Desp=np.zeros(len(z))\n",
+ " \n",
+ " # Se almacena la información de TODA la dinámica en 3 arreglos de salida\n",
+ " # Se suman cada iteración de tiempo para posteriormente hacer su respectiva normalización y promedio\n",
+ " # y encontrar la densidad local contÃnua y dist. de espaciamientos contÃnua\n",
+ "\n",
+ " for i in range(0,rep):\n",
+ " A, B, d_esp = ciclos(condicion_inicial, L, P_R, P_J, P_S, tiempo) \n",
+ "\n",
+ " salida_A = salida_A + A\n",
+ " salida_B = salida_B + B\n",
+ " salida_Desp = salida_Desp + d_esp\n",
+ " \n",
+ " # Cada 1000 iteraciones sacamos un print en pantalla para saber qué tal va\n",
+ " if not(i % 1000):\n",
+ " print(f'Working in iteration number {i} out of {rep}')\n",
+ "\n",
+ " salida_A = salida_A/(rep*2*L)\n",
+ " salida_B = salida_B/(rep*2*L)\n",
+ " salida_Desp = salida_Desp/salida_Desp.sum()\n",
+ "\n",
+ "\n",
+ " #--------------------------------------------------------\n",
+ " #------------------ARCHIVOS------------------------------\n",
+ " #--------------------------------------------------------\n",
+ "\n",
+ " #Escribe 3 archivos txt en la carpeta Archi:\n",
+ " # - Info para A\n",
+ " # - Info para B\n",
+ " # - Info para dist. de espaciamientos\n",
+ "\n",
+ " nombre1 = 'Archi/'+str(nombre)+'A.txt'\n",
+ " nombre2 = 'Archi/'+str(nombre)+'B.txt'\n",
+ " nombre3 = 'Archi/'+str(nombre)+'Desp.txt'\n",
+ "\n",
+ " File_A = open(nombre1, 'w')\n",
+ " File_B = open(nombre2, 'w')\n",
+ " File_P_i = open(nombre3, 'w')\n",
+ "\n",
+ " for i in range(len(x)):\n",
+ " File_A.write(str(x[i])+' '+str(salida_A[i])+'\\n')\n",
+ " File_B.write(str(x[i])+' '+str(salida_B[i])+'\\n')\n",
+ " File_P_i.write(str(z[i])+' '+str(salida_Desp[i])+'\\n')\n",
+ "\n",
+ " File_A.close()\n",
+ " File_B.close()\n",
+ " File_P_i.close()\n",
+ "\n",
+ "\n",
+ " #----------------------------------------------------------\n",
+ " #----------------------GRAFICOS----------------------------\n",
+ " #----------------------------------------------------------\n",
+ "\n",
+ " #-------------------PERFILES DE DENSIDAD-------------------------\n",
+ " fig1=plt.figure(1)\n",
+ " plt.plot(x,salida_A,c='b')\n",
+ " plt.plot(x,salida_B,c='r')\n",
+ " plt.legend(['Particulas A', 'Particulas B'],loc='upper right',bbox_to_anchor=(1.35, 1))\n",
+ " plt.xlabel('x')\n",
+ " plt.ylabel('Perfil de densidad')\n",
+ " plt.show()\n",
+ "\n",
+ " #---------------DISTRIBUCIÓN DE ESPACIAMIENTOS--------------------\n",
+ " fig2=plt.figure(2)\n",
+ " plt.plot(z,salida_Desp,c='b', alpha=0.5)\n",
+ " plt.xlabel('x')\n",
+ " plt.ylabel('Distribución de espaciamientos')\n",
+ " plt.show()\n",
+ "\n",
+ " #-------------------------------------------------------------------\n",
+ " \n",
+ " #---------------\n",
+ " # Dinamica\n",
+ " #---------------\n",
+ " \n",
+ " #Imprime en cada paso de tiempo, el vector concentración\n",
+ " #Con esta opción se puede visualizar lo que ocurre en cada paso de tiempo\n",
+ " \n",
+ " elif opcion=='dinamica':\n",
+ " \n",
+ " salida_din=np.copy(condicion_inicial)\n",
+ " \n",
+ " for i in range(0,tiempo):\n",
+ " print('tiempo ', i)\n",
+ " salida_din, otro = Dinamica(salida_din, L, P_R, P_J, P_S)\n",
+ " print(salida_din)\n",
+ " print(' ')\n",
+ " \n",
+ " #--------------------------------------------------------------------\n",
+ " \n",
+ " #---------------\n",
+ " # Estacionario\n",
+ " #---------------\n",
+ " \n",
+ " #Comprueba si se llega al estado estacionario en el tiempo ingresado. Esto se hace comparando\n",
+ " #el sistema en el tiempo = 'tiempo' y tiempo = 'tiempo' + 1000\n",
+ " \n",
+ " elif opcion=='estacionario':\n",
+ "\n",
+ " pruebas=[]\n",
+ " \n",
+ " #Evolución hasta el tiempo = 'tiempo'\n",
+ " A_est, B_est, Desp_est = ciclos(condicion_inicial, L, P_R, P_J, P_S, tiempo)\n",
+ " \n",
+ " estacionario = B_est - A_est\n",
+ "\n",
+ " pruebas.append(estacionario)\n",
+ " print('Estado en la iteración '+ str(tiempo)+':')\n",
+ " print(estacionario)\n",
+ " print(' ')\n",
+ " \n",
+ " #Evolución hasta el tiempo = 'tiempo + 1000'\n",
+ " A_est2, B_est2, Desp_est2 = ciclos(estacionario, L, P_R, P_J, P_S, 1000)\n",
+ " \n",
+ " estacionario2 = B_est2 - A_est2\n",
+ " \n",
+ " pruebas.append(estacionario2)\n",
+ " print('Estado en la iteración '+ str(tiempo+1000)+':')\n",
+ " print(estacionario2)\n",
+ " print(' ')\n",
+ "\n",
+ " salida_estacionario = pruebas[0] == pruebas[1]\n",
+ " \n",
+ " num_verdadero = list(salida_estacionario).count(True) \n",
+ " \n",
+ " print('Estado estacionario: ' + str(len(salida_estacionario) == num_verdadero))\n",
+ "\n",
+ " return len(salida_estacionario) == num_verdadero\n",
+ " "
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Animaciones\n",
+ "\n",
+ "Para poder ver cómo es la dinámica del sistema, se escriben las siguientes lÃneas de código y funciones para generar una animación."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "#-----------CREACION DEL CANVAS--------------\n",
+ "\n",
+ "L = 5 # 1/2 de la longitud del sistema\n",
+ "x = np.linspace(-L, L, 2*L+1) #Representacion del arreglo\n",
+ "y = np.zeros(2*L+1) #Para representar el arreglo unidimensional\n",
+ "\n",
+ "fig = plt.figure()\n",
+ "ax = plt.axes(xlim=(-L-1, L+1), ylim=(-0.005,0.005))\n",
+ "scatt = ax.scatter([],[],s=70)\n",
+ "plt.close()\n",
+ "\n",
+ "\n",
+ "#------------FUNCIONES PARA FUNCANIMATION--------------------\n",
+ "\n",
+ "# def init():\n",
+ "# scatt.set_offsets([])\n",
+ "# return scatt\n",
+ "\n",
+ "cmap = matplotlib.cm.bwr\n",
+ "norm = matplotlib.colors.Normalize(vmin=-1,vmax=1)\n",
+ "\n",
+ "def animate(i, *fargs):\n",
+ "\n",
+ " concentracion = fargs[i]\n",
+ "\n",
+ " scatt.set_offsets(np.c_[x,y]) #Para correr los datos\n",
+ " scatt.set_color(cmap(norm(concentracion))) #Para los colores de la gráfica\n",
+ " scatt.set_edgecolor('black')\n",
+ "\n",
+ " return scatt,\n",
+ "\n",
+ "\n",
+ "#-----------FUNCIÓN PARA LAS ANIMACIONES (CONTIENE FUNCANIMATION)----------\n",
+ "\n",
+ "def animacion(time, Pr, Pj, Ps):\n",
+ " \n",
+ " #Longitud del arreglo predefinida:\n",
+ " l=5\n",
+ " \n",
+ " # Se genera la dinámica del sistema utilizando la función 'Dinamica'\n",
+ " # hasta llegar al tiempo 'time', los resultados obtenidos se almacenan\n",
+ " # en la lista vec_animate\n",
+ "\n",
+ " vec_animate = []\n",
+ "\n",
+ " condicion_inicial=[-1 if i<l else 1 for i in range(2*l+1)]\n",
+ "\n",
+ " salida = np.copy(condicion_inicial)\n",
+ "\n",
+ " for i in range(time):\n",
+ " salida, otro = Dinamica(salida, l, Pr, Pj, Ps)\n",
+ " vec_animate.append(salida)\n",
+ " \n",
+ " \n",
+ " # Se hace uso de FuncAnimation\n",
+ " \n",
+ " anim = FuncAnimation(fig, animate, frames=time - 1, interval=200, blit=True, repeat=False, fargs = vec_animate)\n",
+ " \n",
+ " \n",
+ " # Se guarda como gif\n",
+ "\n",
+ " nombre_gif = 'anim.gif' \n",
+ "\n",
+ " anim.save(nombre_gif, writer=matplotlib.animation.PillowWriter())\n",
+ " \n",
+ " \n",
+ " # Se transforma el gif en mp4\n",
+ "\n",
+ " nombre_video = 'video_dinamica.mp4'\n",
+ "\n",
+ " clip = mp.VideoFileClip(nombre_gif)\n",
+ " clip.write_videofile(nombre_video)\n",
+ " \n",
+ " return nombre_video\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": 4
+}