Panels_for_Suppl_Fig5c.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib\n",
    "matplotlib.use('TkAgg')\n",
    "from pylab import *\n",
    "import random as rd\n",
    "import numpy as np\n",
    "import networkx as nx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def rectangular_geometric_lattice(F,C,r):\n",
    "    \n",
    "    a = ((C - 1.0) / (F - 1.0))**0.5\n",
    "    d = 1.0/(a * (F-1))\n",
    "\n",
    "    g = nx.Graph()\n",
    "    \n",
    "    pos_x = 0.0\n",
    "    pos_y = 0.0\n",
    "    \n",
    "    for i in range(0,int(F*C)):\n",
    "        \n",
    "        if i == 0:\n",
    "\n",
    "            g.add_node(i)\n",
    "            g.node[i]['x'] = pos_x\n",
    "            g.node[i]['y'] = pos_y\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            g.add_node(i)\n",
    "            \n",
    "            if i % C == 0.0:\n",
    "                \n",
    "                pos_y += d\n",
    "                pos_x = 0.0\n",
    "                \n",
    "                g.node[i]['x'] = pos_x\n",
    "                g.node[i]['y'] = pos_y\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                pos_x += d\n",
    "                \n",
    "                g.node[i]['x'] = pos_x\n",
    "                g.node[i]['y'] = pos_y\n",
    "            \n",
    "            #if g.node[i-1]['x'] == (C-1.0)*d:\n",
    "                \n",
    "            #    g.node[i]['x'] = 0.0\n",
    "            #    g.node[i]['y'] = g.node[i-1]['y']+d\n",
    "                \n",
    "            #else:\n",
    "                \n",
    "            #    g.node[i]['x'] = g.node[i-1]['x']+d\n",
    "            #    g.node[i]['y'] = g.node[i-1]['y']\n",
    "            \n",
    "\n",
    "    for i in g.nodes_iter():\n",
    "\n",
    "        for j in g.nodes_iter():\n",
    "\n",
    "            if i != j and g.has_edge(i,j)==False and\\\n",
    "            (g.node[i]['x'] - g.node[j]['x'])**2.0 + (g.node[i]['y']-g.node[j]['y'])**2.0 <= r**2.0:\n",
    "\n",
    "                g.add_edge(i,j)\n",
    "                \n",
    "    return g\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#ARRANGEMENTS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def random_time(F,C):\n",
    "    \n",
    "    plantas = range(0,int(F*C))\n",
    "    \n",
    "    crop_inmune = rd.sample(plantas,int(0.5*F*C))\n",
    "    crop_suscep = [i for i in plantas if i not in crop_inmune]\n",
    "    \n",
    "    if int(2*C) in crop_suscep:\n",
    "        \n",
    "        crop_infect = [int(2*C)]\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        cambio = rd.sample(crop_suscep,int(1))\n",
    "        crop_inmune.append(int(cambio[0]))\n",
    "        crop_suscep.append(int(2*C))\n",
    "        crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect\n",
    "\n",
    "def row_time(F,C):\n",
    "    \n",
    "    a = ((C - 1.0) / (F - 1.0))**0.5\n",
    "    d = 1.0/(a * (F-1))\n",
    "    \n",
    "    crop_inmune = []\n",
    "    crop_suscep = []\n",
    "    \n",
    "    for i in range(0,int(F)):\n",
    "            \n",
    "        if 1.0*int(i) % 2 == 0:\n",
    "            \n",
    "            crop_suscep += range(i*C,(i+1)*int(C))\n",
    "            #print i,1.0*int(C) % 2, 'sus',crop_suscep\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            crop_inmune += range(i*C, (i+1)*int(C))\n",
    "            #print i,1.0*int(C) % 2, 'inm',crop_inmune\n",
    "    \n",
    "    crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect\n",
    "\n",
    "def monocrop_time(F,C):\n",
    "    \n",
    "    crop_inmune = []\n",
    "    crop_suscep = []\n",
    "    \n",
    "    for i in range(0,int(F*C)):\n",
    "            \n",
    "        crop_suscep.append(i)\n",
    "            \n",
    "    crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect\n",
    "\n",
    "def columna_time(F,C):\n",
    "    \n",
    "   \n",
    "    crop_inmune = []\n",
    "    crop_suscep = []\n",
    "    \n",
    "    for i in range(0,int(C*F)):\n",
    "            \n",
    "        if 1.0*int(i) % 2 == 0:\n",
    "            \n",
    "            crop_suscep.append(i)\n",
    "            #print i,1.0*int(C) % 2, 'sus',crop_suscep\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            crop_inmune.append(i)\n",
    "            #print i,1.0*int(C) % 2, 'inm',crop_inmune\n",
    "    \n",
    "    crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect\n",
    "\n",
    "def chessboard_time(F,C):\n",
    "   \n",
    "    crop_inmune = []\n",
    "    crop_suscep = []\n",
    "    \n",
    "    for i in range(0,int(F)):\n",
    "            \n",
    "        for j in range(0,int(C)):\n",
    "            \n",
    "            if i % 2 == 0:\n",
    "                \n",
    "                if j % 2 == 0:\n",
    "            \n",
    "                    crop_suscep.append(i*C+j)\n",
    "                \n",
    "                else:\n",
    "                    \n",
    "                    crop_inmune.append(i*C+j)\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                if j % 2 == 0:\n",
    "            \n",
    "                    crop_inmune.append(i*C+j)\n",
    "                \n",
    "                else:\n",
    "                    \n",
    "                    crop_suscep.append(i*C+j)\n",
    "    \n",
    "    crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect\n",
    "\n",
    "def patches_time(F,C,Fp,Cp):\n",
    "   \n",
    "    crop_inmune = []\n",
    "    crop_suscep = []\n",
    "    \n",
    "    lista_Fp = [i for i in range(0,int(F)) if i % Fp == 0]\n",
    "    lista_Cp = [i for i in range(0,int(C)) if i % Cp == 0]\n",
    "    \n",
    "    lista_Fp_tipo = []\n",
    "    lista_Cp_tipo = []\n",
    "    \n",
    "    for i in range(0,len(lista_Fp)):\n",
    "        \n",
    "        if i%2==0:\n",
    "            \n",
    "            lista_Fp_tipo.append(1.0) #1 es susceptible\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            lista_Fp_tipo.append(0.0) #0 es inmune\n",
    "    \n",
    "    for i in range(0,len(lista_Cp)):\n",
    "        \n",
    "        if i%2 == 0:\n",
    "            \n",
    "            lista_Cp_tipo.append(1.0) #1 es susceptible\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            lista_Cp_tipo.append(0.0) #0 es inmune\n",
    "\n",
    "    for i in range(0,len(lista_Cp)):\n",
    "        \n",
    "        tipo_x = lista_Cp_tipo[i]\n",
    "        \n",
    "        for x in range(lista_Cp[i],lista_Cp[i]+Cp):\n",
    "            \n",
    "            for j in range(0,len(lista_Fp)):\n",
    "                \n",
    "                tipo_y = lista_Fp_tipo[j]\n",
    "                \n",
    "                for y in range(lista_Fp[j],lista_Fp[j]+Fp):\n",
    "                    \n",
    "                    if tipo_y==tipo_x:\n",
    "                        \n",
    "                        crop_suscep.append(y*C+x)\n",
    "                        #print x,y,y*F+x,'sus'\n",
    "                        \n",
    "                    else:\n",
    "                        \n",
    "                        crop_inmune.append(y*C+x)\n",
    "                        #print x,y,y*F+x,'inm'\n",
    "   \n",
    "    crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect\n",
    "\n",
    "def strips_time(F,C): #Pensado para F=20, C= 50\n",
    "    \n",
    "    plantas = range(0,int(F*C))\n",
    "    \n",
    "    crop_inmune = []\n",
    "    \n",
    "    filas = [0,3,4,7,8,11,12,15,16,19]\n",
    "\n",
    "    for i in filas:\n",
    "            \n",
    "        for j in range(int(i*C),int(((i+1)*C))):\n",
    "\n",
    "            crop_inmune.append(j)\n",
    "        \n",
    "    crop_suscep = [x for x in plantas if x not in crop_inmune]\n",
    "        \n",
    "    crop_infect = [int(2*C)]\n",
    "    \n",
    "    return crop_inmune, crop_suscep, crop_infect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# SIR DYNAMIC WITHOUT LONG-RANGE INTERACTIONS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def q_i_SIN(nodo,lista_p_i):\n",
    "    \n",
    "    global g,beta_cons\n",
    "\n",
    "    aux = 1.0\n",
    "    \n",
    "    for i in g.neighbors_iter(nodo):\n",
    "        \n",
    "        aux *= (1.0 - beta_cons*lista_p_i[i])\n",
    "        \n",
    "    return 1.0 - aux\n",
    "\n",
    "def Markov_evolution_SIR_SIN_cuad(crop_inmune, crop_suscep, crop_infect):\n",
    "    \n",
    "    global g,beta_cons,mu_cons,tmax,lista_infectados_ini,\\\n",
    "    lista_recuperados_ini,lista_recuperados_final\n",
    "    \n",
    "    N0 = len(g.nodes())\n",
    "    \n",
    "    lista_s_i = [] #susceptibles\n",
    "    lista_p_i = [] #infectados\n",
    "    lista_rho_i = [] #recuperados\n",
    "    \n",
    "    for i in g.nodes_iter():\n",
    "\n",
    "        lista_s_i.append(1.0) #susceptibles\n",
    "        lista_p_i.append(0.0) #infectados\n",
    "        lista_rho_i.append(0.0) #recuperados\n",
    "        \n",
    "    N0 = len(g.nodes())\n",
    "    \n",
    "    cant_inmunes_t0 = len(crop_inmune)\n",
    "    lista_infectados_ini = crop_infect[:]\n",
    "    lista_recuperados_ini = crop_inmune[:]\n",
    "    \n",
    "    #print 'inmunes:',1.0*len(crop_inmune)/N0,'infectados:',1.0*len(crop_infect)/len(crop_suscep)\n",
    "\n",
    "    for i in crop_inmune:\n",
    "        \n",
    "        lista_s_i[i] =  0.0\n",
    "        lista_p_i[i] = 0.0\n",
    "        lista_rho_i[i] = 1.0\n",
    "        \n",
    "    for i in crop_infect :\n",
    "        \n",
    "        lista_s_i[i] =  0.0\n",
    "        lista_p_i[i] = 1.0\n",
    "        lista_rho_i[i] = 0.0\n",
    "\n",
    "    \n",
    "    amount_inf.append(1.0*sum(lista_p_i)/(N0-cant_inmunes_t0))\n",
    "    amount_sus.append(1.0*sum(lista_s_i)/(N0-cant_inmunes_t0))\n",
    "    amount_rec.append(1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0))\n",
    "    \n",
    "    t = 0\n",
    "    terminar = False\n",
    "    \n",
    "    while t <= tmax and terminar==False:\n",
    "    \n",
    "        nuevo_s_i = []\n",
    "        nuevo_p_i = []\n",
    "        nuevo_rho_i = []\n",
    "\n",
    "        for a in g.nodes_iter():\n",
    "            \n",
    "            if lista_rho_i[a] == 1.0:\n",
    "                \n",
    "                nuevo_s_i.append(0.0)\n",
    "                nuevo_p_i.append(0.0)\n",
    "                nuevo_rho_i.append(1.0)\n",
    "                \n",
    "            else:  \n",
    "\n",
    "                q_i_nodo = q_i_SIN(a,lista_p_i)\n",
    "\n",
    "                aux_nuevo_p_i = lista_p_i[a]*(1.0 - mu_cons) + (1.0 - lista_p_i[a] - lista_rho_i[a])*q_i_nodo\n",
    "                aux_nuevo_rho_i = lista_rho_i[a] + mu_cons*lista_p_i[a]\n",
    "\n",
    "                nuevo_s_i.append(1.0 - aux_nuevo_p_i - aux_nuevo_rho_i)\n",
    "                nuevo_p_i.append(aux_nuevo_p_i)\n",
    "                nuevo_rho_i.append(aux_nuevo_rho_i)\n",
    "        \n",
    "        if max(nuevo_p_i) < 1e-6:\n",
    "\n",
    "            terminar = True\n",
    "\n",
    "        lista_s_i = nuevo_s_i[:]\n",
    "        lista_p_i = nuevo_p_i[:]\n",
    "        lista_rho_i = nuevo_rho_i[:]\n",
    "\n",
    "        \n",
    "        amount_inf.append(1.0*sum(lista_p_i)/(N0-cant_inmunes_t0))\n",
    "        amount_sus.append(1.0*sum(lista_s_i)/(N0-cant_inmunes_t0))\n",
    "        amount_rec.append(1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0))\n",
    "\n",
    "        t += 1\n",
    "\n",
    "    \n",
    "    lista_recuperados_final=[i for i in g.nodes_iter() if lista_rho_i[i] > lista_s_i[i]]\n",
    "    \n",
    "    return 1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def matriz_distancia():\n",
    "    \n",
    "    global g\n",
    "    \n",
    "    dic_shortest = nx.shortest_path(g)\n",
    "\n",
    "    M_nueva = []\n",
    "\n",
    "    for i in range(0,len(g.nodes())):\n",
    "\n",
    "        fila_aux = []\n",
    "\n",
    "        fila = dic_shortest.get(i)\n",
    "\n",
    "        for k in range(0,len(g.nodes())):\n",
    "\n",
    "            fila_aux.append(len(fila.get(k))-1.0)\n",
    "\n",
    "        M_nueva.append(fila_aux)\n",
    "    \n",
    "    return M_nueva\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def matriz_alargamiento():\n",
    "    \n",
    "    global g,crop_inmune\n",
    "    \n",
    "    dic_shortest = nx.shortest_path(g)\n",
    "\n",
    "    M_nueva = []\n",
    "\n",
    "    for i in range(0,len(g.nodes())):\n",
    "\n",
    "        fila_aux = []\n",
    "\n",
    "        fila = dic_shortest.get(i)\n",
    "\n",
    "        for k in range(0,len(g.nodes())):\n",
    "            \n",
    "            camino_ik = fila.get(k)\n",
    "            \n",
    "            aux = 0.0\n",
    "            \n",
    "            for p in camino_ik:\n",
    "                \n",
    "                if p in crop_inmune:\n",
    "                    \n",
    "                    aux += 1.0\n",
    "\n",
    "            fila_aux.append(aux)\n",
    "\n",
    "        M_nueva.append(fila_aux)\n",
    "    \n",
    "    return M_nueva"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# SIR DYNAMIC WITH TRAP CROPS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def q_i_MELLIN_SEXY3_mod(nodo,lista_p_i,s,gamma):\n",
    "    \n",
    "    global g,beta_cons,M_distancia,M_alargamiento,crop_suscep\n",
    "\n",
    "    aux = 1.0\n",
    "    \n",
    "    for i in crop_suscep:\n",
    "\n",
    "        if i != nodo:\n",
    "                \n",
    "            if M_alargamiento[nodo][i] == 0.0:\n",
    "\n",
    "                aux *= (1.0 - 1.0*beta_cons*lista_p_i[i]/((M_distancia[nodo][i])**s))\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                aux *= (1.0 - 1.0*beta_cons*lista_p_i[i]/((M_distancia[nodo][i])**(gamma*s)))\n",
    " \n",
    "    return (1.0 - aux)\n",
    "    \n",
    "\n",
    "def Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(s,crop_inmune, crop_suscep, crop_infect):\n",
    "    \n",
    "    global g,beta_cons,mu_cons,tmax,lista_infectados_ini,\\\n",
    "    lista_recuperados_ini,lista_recuperados_final,M_distancia,M_alargamiento,rho_est,gamma\n",
    "    \n",
    "    N0 = len(g.nodes())\n",
    "    \n",
    "    lista_s_i = [] #susceptibles\n",
    "    lista_p_i = [] #infectados\n",
    "    lista_rho_i = [] #recuperados\n",
    "    \n",
    "    for i in g.nodes_iter():\n",
    "\n",
    "        lista_s_i.append(1.0) #susceptibles\n",
    "        lista_p_i.append(0.0) #infectados\n",
    "        lista_rho_i.append(0.0) #recuperados\n",
    "        \n",
    "    N0 = len(g.nodes())\n",
    "    \n",
    "    cant_inmunes_t0 = len(crop_inmune)\n",
    "    lista_infectados_ini = crop_infect[:]\n",
    "    lista_recuperados_ini = crop_inmune[:]\n",
    "    \n",
    "    #print 'inmunes:',1.0*len(crop_inmune)/N0,'infectados:',1.0*len(crop_infect)/len(crop_suscep)\n",
    "\n",
    "\n",
    "    for i in crop_inmune:\n",
    "        \n",
    "        lista_s_i[i] =  0.0\n",
    "        lista_p_i[i] = 0.0\n",
    "        lista_rho_i[i] = 1.0\n",
    "        \n",
    "    for i in crop_infect :\n",
    "        \n",
    "        lista_s_i[i] =  0.0\n",
    "        lista_p_i[i] = 1.0\n",
    "        lista_rho_i[i] = 0.0\n",
    "\n",
    "    \n",
    "    amount_inf.append(1.0*sum(lista_p_i)/(N0-cant_inmunes_t0))\n",
    "    amount_sus.append(1.0*sum(lista_s_i)/(N0-cant_inmunes_t0))\n",
    "    amount_rec.append(1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0))\n",
    "    \n",
    "    \n",
    "    t = 0\n",
    "    terminar = False\n",
    "    \n",
    "    while t <= tmax and terminar==False:\n",
    "    \n",
    "        nuevo_s_i = []\n",
    "        nuevo_p_i = []\n",
    "        nuevo_rho_i = []\n",
    "\n",
    "        for a in g.nodes_iter():\n",
    "            \n",
    "            if g.node[a]['buscar'] == True: #lista_p_i[a] < lista_rho_i[a]:\n",
    "                \n",
    "                g.node[a]['time'] = t\n",
    "                \n",
    "                if 1.0 - lista_p_i[a] - lista_rho_i[a] < lista_rho_i[a]:\n",
    "                \n",
    "                    g.node[a]['buscar'] = False\n",
    "            \n",
    "            if s >= 100:\n",
    "            \n",
    "                q_i_nodo = q_i_SIN(a,lista_p_i)\n",
    "                \n",
    "            else:\n",
    "                \n",
    "                q_i_nodo = q_i_MELLIN_SEXY3_mod(a,lista_p_i,s,gamma) #q_i_MELLIN(a,lista_p_i,s)\n",
    "\n",
    "            aux_nuevo_p_i = lista_p_i[a]*(1.0 - mu_cons) + (1.0 - lista_p_i[a] - lista_rho_i[a])*q_i_nodo\n",
    "            aux_nuevo_rho_i = lista_rho_i[a] + mu_cons*lista_p_i[a]\n",
    "\n",
    "            nuevo_s_i.append(1.0 - aux_nuevo_p_i - aux_nuevo_rho_i)\n",
    "            nuevo_p_i.append(aux_nuevo_p_i)\n",
    "            nuevo_rho_i.append(aux_nuevo_rho_i)\n",
    "\n",
    "        \n",
    "        if max(nuevo_p_i) < 1e-6:\n",
    "\n",
    "            terminar = True\n",
    "\n",
    "        lista_s_i = nuevo_s_i[:]\n",
    "        lista_p_i = nuevo_p_i[:]\n",
    "        lista_rho_i = nuevo_rho_i[:]\n",
    "        \n",
    "        amount_inf.append(1.0*sum(lista_p_i)/(N0-cant_inmunes_t0))\n",
    "        amount_sus.append(1.0*sum(lista_s_i)/(N0-cant_inmunes_t0))\n",
    "        amount_rec.append(1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0))\n",
    "\n",
    "        t += 1\n",
    "        \n",
    "    \n",
    "    rho_est = lista_rho_i[:]\n",
    "    lista_recuperados_final=[i for i in g.nodes_iter() if lista_rho_i[i] > lista_s_i[i]]\n",
    "    \n",
    "    transicion = [g.node[i]['time'] for i in g.nodes_iter() if ((i in crop_suscep) and (lista_rho_i[i] > lista_s_i[i]))]\n",
    "    \n",
    "    print 'v =',1.0*len(transicion)/t\n",
    "    print 'R(t = inf) =',1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0)\n",
    "    \n",
    "    return 1.0*(sum(lista_rho_i)-cant_inmunes_t0)/(N0-cant_inmunes_t0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#LATTICE GENERATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "F=20\n",
    "C=50\n",
    "\n",
    "Fp=5\n",
    "Cp=5\n",
    "\n",
    "a_2 = (C - 1.0) / (F - 1.0)\n",
    "d_2 = 1.0/(a_2 * (F-1)*(F-1))\n",
    "\n",
    "r=1.001*(d_2**0.5)*(2**0.5)\n",
    "\n",
    "g = rectangular_geometric_lattice(F,C,r)\n",
    "M_distancia = matriz_distancia()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mell = 4.0\n",
    "\n",
    "beta_cons = 0.5\n",
    "mu_cons = 0.5\n",
    "gamma = 2.0\n",
    "tmax = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#RANDOM ARRANGEMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "name =  'predefined_random_arrangement.txt'\n",
    "\n",
    "resultado = []\n",
    "\n",
    "with open(name) as inputfile:\n",
    "\n",
    "    for line in inputfile:\n",
    "\n",
    "        resultado.append(line.strip().split(','))\n",
    "\n",
    "    crop_inmune_random = [int(float(x.strip(' \"'))) for x in resultado[0]]\n",
    "    crop_suscep_random = [int(float(x.strip(' \"'))) for x in resultado[1]]\n",
    "    crop_infect_random = [int(float(x.strip(' \"'))) for x in resultado[2]]\n",
    "    \n",
    "crop_inmune = crop_inmune_random[:]\n",
    "crop_suscep = crop_suscep_random[:]\n",
    "crop_infect = crop_infect_random[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 340\n",
      "Tiempo medio de transicion = 37.2382352941\n",
      "Duracion de la dinamica SIR = 1893\n",
      "Altura media de todas las columnas susceptibles = 630.762\n",
      "R(asintótico, t = inf) = 0.618305036241\n",
      "tasa v = 0.179609086107\n",
      "R = 0.618305036241\n"
     ]
    }
   ],
   "source": [
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune_random, crop_suscep_random, crop_infect_random)\n",
    "\n",
    "\n",
    "max_col_bar = 0.0\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "    \n",
    "    if max_col_bar < g.node[i]['time']:\n",
    "        \n",
    "        max_col_bar = g.node[i]['time']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#VISUALIZATION"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1892 1892\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep_random:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune_random:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#ROW ARRANGEMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 500\n",
      "Tiempo medio de transicion = 46.65\n",
      "Duracion de la dinamica SIR = 107\n",
      "Altura media de todas las columnas susceptibles = 46.65\n",
      "R(asintótico, t = inf) = 0.825134507526\n",
      "tasa v = 4.67289719626\n"
     ]
    }
   ],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n",
    "\n",
    "\n",
    "crop_inmune, crop_suscep, crop_infect = row_time(F,C)\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "\n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune, crop_suscep, crop_infect)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1892 75\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#COLUMN ARRANGEMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 500\n",
      "Tiempo medio de transicion = 55.544\n",
      "Duracion de la dinamica SIR = 115\n",
      "Altura media de todas las columnas susceptibles = 55.544\n",
      "R(asintótico, t = inf) = 0.79226415002\n",
      "tasa v = 4.34782608696\n"
     ]
    }
   ],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n",
    "\n",
    "\n",
    "crop_inmune, crop_suscep, crop_infect = columna_time(F,C)\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune, crop_suscep, crop_infect)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1892 84\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#CHESSBOARD ARRANGEMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 500\n",
      "Tiempo medio de transicion = 17.39\n",
      "Duracion de la dinamica SIR = 53\n",
      "Altura media de todas las columnas susceptibles = 17.39\n",
      "R(asintótico, t = inf) = 0.980639071291\n",
      "tasa v = 9.43396226415\n"
     ]
    }
   ],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n",
    "\n",
    "\n",
    "crop_inmune, crop_suscep, crop_infect = chessboard_time(F,C)\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune, crop_suscep, crop_infect)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1892 30\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#PATCHES ARRANGEMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 500\n",
      "Tiempo medio de transicion = 15.608\n",
      "Duracion de la dinamica SIR = 45\n",
      "Altura media de todas las columnas susceptibles = 15.608\n",
      "R(asintótico, t = inf) = 0.996928289484\n",
      "tasa v = 11.1111111111\n"
     ]
    }
   ],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n",
    "\n",
    "\n",
    "crop_inmune, crop_suscep, crop_infect = crop_inmune, crop_suscep, crop_infect = patches_time(F,C,Fp,Cp)\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune, crop_suscep, crop_infect)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1892 24\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#STRIPS ARRANGEMENT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 500\n",
      "Tiempo medio de transicion = 21.146\n",
      "Duracion de la dinamica SIR = 52\n",
      "Altura media de todas las columnas susceptibles = 21.146\n",
      "R(asintótico, t = inf) = 0.995517044071\n",
      "tasa v = 9.61538461538\n"
     ]
    }
   ],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n",
    "\n",
    "\n",
    "crop_inmune, crop_suscep, crop_infect = strips_time(F,C)\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune, crop_suscep, crop_infect)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1892 30\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#MONOCROP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodos susceptibles en los que hay cambio = 1000\n",
      "Tiempo medio de transicion = 9.081\n",
      "Duracion de la dinamica SIR = 34\n",
      "Altura media de todas las columnas susceptibles = 9.081\n",
      "R(asintótico, t = inf) = 0.99968389883\n",
      "tasa v = 29.4117647059\n"
     ]
    }
   ],
   "source": [
    "amount_inf = []\n",
    "amount_sus = []\n",
    "amount_rec = []\n",
    "lista_infectados_ini = []\n",
    "lista_recuperados_ini = []\n",
    "lista_recuperados_final = []\n",
    "\n",
    "\n",
    "crop_inmune, crop_suscep, crop_infect =  monocrop_time(F,C)\n",
    "\n",
    "for i in g.nodes_iter():\n",
    "        \n",
    "    g.node[i]['time'] = 0\n",
    "    g.node[i]['buscar'] = True\n",
    "    \n",
    "M_alargamiento = matriz_alargamiento()\n",
    "M_distancia = matriz_distancia()\n",
    "    \n",
    "R = Markov_evolution_SIR_MELLIN_SEXY_cuad3_time_mod(mell,crop_inmune, crop_suscep, crop_infect)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 1892 13\n",
      "1 1892\n"
     ]
    }
   ],
   "source": [
    "aux = []\n",
    "\n",
    "for j in crop_suscep:\n",
    "\n",
    "    aux.append(g.node[j]['time'])\n",
    "            \n",
    "min_time = min(aux)\n",
    "max_time = max_col_bar\n",
    "    \n",
    ",max(aux)\n",
    "\n",
    "cmap = plt.get_cmap('jet_r')\n",
    "colores = [cmap(i) for i in np.linspace(0, 1, int(max_time-(min_time-1)))]\n",
    "\n",
    "#fig = plt.figure()\n",
    "#ax = fig.add_subplot(111)\n",
    "    \n",
    "ymin = 0; ymax = F; dy = 1\n",
    "xmin = 0; xmax = C; dx = 1\n",
    "\n",
    "# transform x and y to boundaries of x and y\n",
    "x2,y2 = np.meshgrid(np.arange(xmin,xmax+dx,dx)-dx/2.,np.arange(ymin,ymax+dy,dy)-dy/2.)\n",
    "\n",
    "Z = [] # evaluation of the function on the grid\n",
    "\n",
    "for j in range(0,int(F)):\n",
    "    \n",
    "    aux_Z = []\n",
    "    \n",
    "    for i in range(0,int(C)):\n",
    "        \n",
    "        nodo = int(j*C) + i\n",
    "        \n",
    "        if nodo in crop_inmune:\n",
    "        \n",
    "            aux_Z.append(float('nan'))\n",
    "            \n",
    "        else:\n",
    "            \n",
    "            aux_Z.append(g.node[nodo]['time'])\n",
    "            \n",
    "    Z.append(aux_Z)\n",
    "    \n",
    "\n",
    "import numpy.ma as ma\n",
    "\n",
    "Zm = ma.masked_where(np.isnan(Z),Z)\n",
    "#plt.pcolormesh(X,Y,Zm.T)\n",
    "\n",
    "#im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.Normalize(vmin=1, vmax=max_col_bar))#bordes sin difuminar\n",
    "im = pcolormesh(x2,y2,Zm,cmap='jet_r',norm=matplotlib.colors.LogNorm(vmin=1, vmax=max_col_bar))\n",
    "\n",
    "vmin=1\n",
    "vmax=max_col_bar\n",
    "\n",
    "#ylabel('Rows',fontsize=30)\n",
    "\n",
    "axis([x2.min(),x2.max(),y2.min(),y2.max()])\n",
    "\n",
    "\n",
    "\n",
    "ax = subplot() # Defines ax variable by creating an empty plot\n",
    "\n",
    "# Turn off tick labels\n",
    "ax.set_yticklabels([])\n",
    "ax.set_xticklabels([])\n",
    "\n",
    "ax.set_aspect('equal')\n",
    "tight_layout()\n",
    "\n",
    "show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}