<file_sep>import re
import math

#Esta función me da el peso del vínculo
def ZipfGravity(k,pop1,pop2,distance):
    return k*pop1*pop2/distance

#Esta función me convierte a grados las latitudes y longitudes
def todegree(latorlong):
    deg, minutes, seconds, direction = re.split('[°\'"]', latorlong)
    degree = (float(deg) + float(minutes)/60 + float(seconds)/3600)*(-1 if direction in ['W', 'S'] else 1)
    return degree

#Esta función me da la distancia entre los dos puntos
def coordinatetodistance(lat1,long1,lat2,long2):
    #Convierto los grados a radianes
    lat1 = math.radians(lat1)
    lat2 = math.radians(lat2)
    long1 = math.radians(long1)
    long2 = math.radians(long2)

    #Hallo las diferencias entre las posiciones
    dlon = long2-long1
    dlat = lat2-lat1

    #Hallo un cateto y el ángulo que forman ambos lugares con respecto al centro
    a = math.sin(dlat/2)**2 + math.cos(lat1)*math.cos(lat2)*math.sin(dlon/2)**2
    c = 2*math.atan2(math.sqrt(a), math.sqrt(1-a))
    
    #Defino el radio de la Tierra y hallo el arco
    R = 6371.0
    return R*c
<file_sep>import network as net
import SIRODE as SIR
import ZipfDistance as ZD
import networkx as nx
import numpy as np
import random as ran
import matplotlib.pyplot as plt

types = 3

pop0 = 4.9e7

pop = [0]*types
pop[0] = 0.3*pop0
pop[1] = 0.3*pop0
pop[2] = 0.4*pop0

aux = [0]*types
beta0 =[aux]*types
beta0[0][0] = 1.95
beta0[1][1] = 0.75*1.95
beta0[2][2] = 0.5*1.95
beta0[0][1] = beta0[1][0] = 0.875
beta0[0][2] = beta0[2][0] = 0.75
beta0[2][1] = beta0[1][2] = 0.625
gamma0 = 0.627
sigma0 = 0.22

sus = [0]*types
inf = [0]*types
exp = [0]*types
rec = [0]*types

for i in range(types):
    sus[i] = pop[i]

inf[0] += 1
sus[0] -= 1

ti = 0

deltat = 300

S1,S2,S3,E1,E2,E3,I1,I2,I3,R1,R2,R3 = np.array(SIR.resolviendo(ti,deltat,sus,exp,inf,rec,beta0,gamma0,sigma0,pop,dt=int(deltat*100)))

t = np.linspace(ti,deltat,deltat*100)

#plt.xlim(0,10)
#plt.ylim(-1,5)
plt.plot(t,I1)
plt.plot(t,I2)
plt.plot(t,I3)
plt.show()
<file_sep>import scipy.integrate as sciin
import numpy as np

#Esta función plantea las ecuaciones del modelo SEIR
def modelo_seir(y,t,beta,gamma,sigma,pop):
    #Obtengo los agentes
    S = []
    for i in range(3):
        S.append(y[i])
    E = []
    for i in range(3,6):
        E.append(y[i])
    I = []
    for i in range(6,9):
        I.append(y[i])
    R = []
    for i in range(9,12):
        R.append(y[i])

    #Hay que tener en cuenta que S e I tienen 3 tipos distintos. Son listas.
    dS_dt = [0]*len(S)
    dE_dt = [0]*len(E)
    dI_dt = [0]*len(I)
    dR_dt = [0]*len(R)

    #Tener en cuenta que beta es una matriz
    #Hago el ciclo para los susceptibles
    for i in range(len(S)):
        betaI = 0 
        for j in range(len(beta)):
            betaI += beta[i][j]*I[j]  
        dS_dt[i] = -betaI*S[i]/pop[i]
        
    #Hago el ciclo sobre los expuestos
    for i in range(len(S)):
        dE_dt[i] = -dS_dt[i] - sigma*E[i]

    #Hago el ciclo para los infectados
    for i in range(len(I)):
        dI_dt[i] = sigma*E[i] - gamma*I[i]

    #Hago el ciclo sobre los recuperados
    for i in range(len(I)):
        dR_dt[i] = gamma*I[i]

    result = []
    for i in dS_dt:
        result.append(i)
    for i in dE_dt:
        result.append(i)
    for i in dI_dt:
        result.append(i)
    for i in dR_dt:
        result.append(i)

    #Devuelvo los parámetros
    return result

#Defino la función que me resuelve el sistema de ecuaciones
def resolviendo(ti,tf,S0,E0,I0,R0,beta,gamma,sigma,pop,dt=100):
    t = np.linspace(ti,tf,dt)
    y = []
    for i in S0:
        y.append(i)
    for i in E0:
        y.append(i)
    for i in I0:
        y.append(i)
    for i in R0:
        y.append(i)
    
    solucion = sciin.odeint(modelo_seir, y, t, args=(beta,gamma,sigma,pop))
    
    return (solucion[:,0],solucion[:,1],solucion[:,2],solucion[:,3],solucion[:,4],solucion[:,5],solucion[:,6],solucion[:,7],solucion[:,8],solucion[:,9],solucion[:,10],solucion[:,11])
<file_sep># Cosecha_COVID

Simulación por el método directo de Gillespie de dinámica de poblaciones en una red, entrando en un nodo E y saliendo en un nodo S que representan el entorno de la red considerada. 
Este entorno se construyó para simular aislamiento y contagio en sistemas con aislamiento local en espacio y tiempo. 
<file_sep>import matplotlib.pyplot as plt
import numpy as np

my_data = np.genfromtxt("normalizado.csv", delimiter='\t', dtype=None, encoding='utf-8-sig')

departamentos = []
peso = []

for i in range(len(my_data)):
    departamentos.append(my_data[i][0])
    peso.append(my_data[i][1])

#plt.xticks(rotation = 90)
plt.ylabel("Departamentos")
plt.xlabel("Pesos alrededor del nodo")
plt.barh(departamentos, peso)
plt.title("Suma de los pesos alrededor del nodo")   
#plt.savefig("Figure_Pesos.png")
plt.show()

<file_sep>import scipy.integrate as sciin
import numpy as np

#Esta función plantea las ecuaciones del modelo SEIR
def modelo_seir(y,t,beta,gamma,sigma,pop):
    S,E,I,R = y
    dS_dt = -beta*S*I/pop
    dE_dt = beta*S*I/pop - sigma*E
    dI_dt = sigma*E - gamma*I
    dR_dt = gamma*I
    return ([dS_dt,dE_dt,dI_dt,dR_dt])

#Defino la función que me resuelve el sistema de ecuaciones
def resolviendo(ti,tf,S0,E0,I0,R0,beta,gamma,sigma,dt=100):
    t = np.linspace(ti,tf,dt)
    pop = S0+E0+I0+R0
    solucion = sciin.odeint(modelo_seir, [S0,E0,I0,R0], t, args=(beta,gamma,sigma,pop))
    return (solucion[:,0],solucion[:,1],solucion[:,2],solucion[:,3])
<file_sep>import networkx as nx
import matplotlib.pyplot as plt
import numpy as np

#Defino la función para dibujar la red
def net_drawing(G,pos,labels,title):
    nx.draw_networkx_labels(G, pos=pos, labels=labels)
    nx.draw(G, pos=pos, node_size=10, width=0.5)
    plt.title(title)
    plt.show()
    plt.clf()

#Defino la función para hacer el intercambio de agentes
def swap(G, matrix):
    #Hallo la suma de los pesos alrededor de cada nodo
    suma = []
    for i in range(len(matrix)):
        suma.append(np.sum(matrix[i]))

    '''
    Obtengo los diccionarios con los Susceptibles, Expuestos, Infectados y
    Recuperados de cada nodo
    '''
    sus = nx.get_node_attributes(G,'Susceptibles')
    exp = nx.get_node_attributes(G,'Expuestos')
    inf = nx.get_node_attributes(G,'Infectados')
    rec = nx.get_node_attributes(G,'Recuperados')

    '''
    Defino unos diccionarios donde pondré los nuevos Susceptibles, Expuestos,
    Infectados y Recuperados de cada nodo
    '''
    asus = {}
    aexp = {}
    ainf = {}
    arec = {}
    
    #Defino la proporción de personas de cada tipo que se van y las resto
    for i in range(len(matrix)):
        total = sus[i] + exp[i] + inf[i] + rec[i]
        value = suma[i]
        asus[i] = (sus[i]/total)*value
        sus[i] -= asus[i]
        aexp[i] = (exp[i]/total)*value
        exp[i] -= aexp[i]
        ainf[i] = (inf[i]/total)*value
        inf[i] -= ainf[i]
        arec[i] = (rec[i]/total)*value
        rec[i] -= arec[i]

    #Hago la asignación de esas personas a los nuevos nodos
    for i in range(len(matrix)):
        #Hago el ciclo sobre los vecinos del nodo
        for j in range(len(matrix)):
            value = matrix.item((i,j))/suma[i]
            sus[j] += value*asus[i]
            exp[j] += value*aexp[i]
            inf[j] += value*ainf[i]
            rec[j] += value*arec[i]

    #Le asigno los nuevos valores de las personas a los nodos
    nx.set_node_attributes(G, sus, 'Susceptibles')
    nx.set_node_attributes(G, exp, 'Expuestos')
    nx.set_node_attributes(G, inf, 'Infectados')
    nx.set_node_attributes(G, rec, 'Recuperados')

    return G

#Esta función me imprime los datos de las características de los nodos
def print_data(i,NS,NE,NI,NR):
    with open("Data_1/node_" + str(i) + ".csv", "a") as myfile:
        for j in range(len(NS)):
            myfile.write(str(NS[j]) + '\t' + str(NE[j]) + '\t' + str(NI[j]) + '\t' + str(NR[j]) + '\n')
<file_sep>import network as net
import SIRODE as SIR
import ZipfDistance as ZD
import networkx as nx
import numpy as np
import random as ran

#Leo le archivo donde está la información de población y ubicación.
my_data = np.genfromtxt("BaseCol_Dep.csv", delimiter=';', dtype=None, encoding='utf-8-sig')

#Defino el número de nodos
N = len(my_data)

#Guardo los atributos de nombre y población, y la propiedad de posición
name = {}
pop = {}
lat = []
lon = []
for i in range(N):
    name[i] = my_data[i][0]
    pop[i] = my_data[i][1]
    lat.append(my_data[i][2])
    lon.append(my_data[i][3])

#Creo la red con el número de nodos adecuados
G = nx.empty_graph(N)

#Creo los archivos donde se van a imprimir los distancias y los Zipf
file1 = open("vinculos.csv", "w")
file2 = open("zipf.csv", "w")

#Imprimo la distancia, el Zipf y agrego el vínculo a la red
kk = 1.3345e-8
for i in range(N):
    for j in range(i+1,N):
        #Hallo la distancia
        dist = ZD.coordinatetodistance(lat[i],lon[i],lat[j],lon[j])
        #Hallo el zipf
        zipf = ZD.ZipfGravity(kk,pop[i],pop[j],dist)
        #Imprimo la distancia y el zipf en los archivos correspondientes
        file1.write(str(name[i]) + '\t' + str(name[j]) + '\t' + str(dist) + '\n')
        file2.write(str(name[i]) + '\t' + str(name[j]) + '\t' + str(zipf) + '\n')
        #Agrego el vínculo con su peso
        G.add_edge(i, j, weight=float(zipf))
file1.close()
file2.close()

#Obtener la matriz de pesos
matrix = nx.to_numpy_matrix(G)

#Hallo la suma de los pesos alrededor de un nodo
sumv = []
for i in range(N):
    sumv.append(np.sum(matrix[i]))
aux = sumv[:]
sumv.sort()

#Los imprimo
file1 = open("Suma_pesos.csv", "w")
for i in range(N):
    for j in range(N):
        if(sumv[i] == aux[j]):
            file1.write(name[j] + '\t' + str(sumv[i]) + '\n')
            break
file1.close()

#Defino las variables de las personas en la red
I0 = 1
beta0 = 1.95
gamma0 = 0.8
sigma0 = 0.22

#Agrego el nombre de cada nodo como un atributo de cada nodo
nx.set_node_attributes(G, name, 'Nombre')
        
#Defino el diccionario que me va a dar la propiedad de Susceptibles, Expuesto, Infectado y Recuperado
sus = {}
exp = {}
inf = {}
rec = {}
for i in range(N):
    sus[i] = pop[i]
    exp[i] = 0
    inf[i] = 0
    rec[i] = 0
    
#Cundinamarca es el nodo número 2, entonces le sumo un infectado
inf[2] += 1
sus[2] -= 1

#Guardo los Susceptibles, Expuestos, Infectados y Recuperados como atributos del nodo
nx.set_node_attributes(G, sus, 'Susceptibles')
nx.set_node_attributes(G, exp, 'Expuestos')
nx.set_node_attributes(G, inf, 'Infectados')
nx.set_node_attributes(G, rec, 'Recuperados')    

#Le doy una forma circular para poderlo ver mejor
pos = nx.circular_layout(G)

print(name)

#infected = np.genfromtxt("casos_importados.csv", delimiter='\t', dtype=None, encoding='utf-8-sig')

#Hacer el ciclo sobre T pasos de tiempo
T = 2
dt = 100
ti = 0
tf = ti + dt
for i in range(T):
    '''
    if(i<30):
        #Obtengo el atributo de infectados y lo modifico
        inf = nx.get_node_attributes(G, 'Infectados')
        for j in range(1,len(infected)):
            if(int(infected[j][0]) == i):
                inf[int(infected[j][2])] += int(infected[j][4])
                #Los vuelvo a añadir a la red
        nx.set_node_attributes(G, inf, 'Infectados')
    '''
            
    #Obtengo los diccionarios de cada tipo de persona
    sus = nx.get_node_attributes(G, 'Susceptibles')
    exp = nx.get_node_attributes(G, 'Expuestos')
    inf = nx.get_node_attributes(G, 'Infectados')
    rec = nx.get_node_attributes(G, 'Recuperados')

    #Hago el ciclo sobre cada nodo haciendo el SIR
    for j in range(N):
        NS,NE,NI,NR = np.array(SIR.resolviendo(ti,tf,sus[j],exp[j],inf[j],rec[j],beta0,gamma0,sigma0))
        #Imprimo los datos
        net.print_data(j,NS,NE,NI,NR)
        #Le asigno los nuevos valores de cada variable al diccionario
        sus[j] = NS[-1]
        exp[j] = NE[-1]
        inf[j] = NI[-1]
        rec[j] = NR[-1]
    
    #Le asigno nuevamente los atributos
    nx.set_node_attributes(G, sus, 'Susceptibles')
    nx.set_node_attributes(G, exp, 'Expuestos')
    nx.set_node_attributes(G, inf, 'Infectados')
    nx.set_node_attributes(G, rec, 'Recuperados')
    
    #Hago el intercambio entre los nodos
    G = net.swap(G, matrix)

    #Dibujo la red con la propiedad de expuestos
    #net.net_drawing(G,pos,inf,'Infectados')
