def SIRD(graph, dict_p, tmax = 100, IC = {}, node_seed=-1):
for key in dict_p.keys():
if key == 'inf_rate':
inf_rate = dict_p['inf_rate']
elif key == 'rec_rate':
rec_rate = dict_p['rec_rate']
elif key == 'death_rate':
death_rate = dict_p['death_rate']
elif key == 'N_init':
N_init = dict_p['N_init']
H = nx.DiGraph() #the spontaneous transitions
H.add_edge('Inf', 'Dead', rate = death_rate,weight_label='expose2infect_weight')
H.add_edge('Inf', 'Rec', rate = rec_rate)
J = nx.DiGraph() #the induced transitions
J.add_edge(('Inf', 'Sus'), ('Inf', 'Inf'), rate = inf_rate)
if len(IC) == 0:
set_node_status(graph, dict_p,node_seed=node_seed)
IC = defaultdict(lambda:'Sus')
for i in list(np.random.randint(dict_p['N'],size = math.ceil(N_init))):
IC[i] = 'Inf'
return_statuses = ['Sus', 'Inf', 'Rec', 'Dead']
sim = EoN.Gillespie_simple_contagion(graph, H, J, IC, return_statuses, tmax=tmax, \
return_full_data=True)
return sim,dict_p
def run_until_prev(input_net, H, J, initial_conditions,
prev_start_SD):
net = input_net.copy()
next_step_IC = initial_conditions
t = None
S = None
E = None
I = None
R = None
curr_prev = 0
while (curr_prev < prev_start_SD):
# Run for one time step ------------------------------------------------
full_net_one_step = EoN.Gillespie_simple_contagion(net, H, J, next_step_IC, return_statuses, tmax = 1, return_full_data=True)
t_one_step = full_net_one_step.t()
S_one_step = full_net_one_step.S()
E_one_step = full_net_one_step.summary()[1]['E']
I_one_step = full_net_one_step.I()
R_one_step = full_net_one_step.R()
# Concatenate results of the single time step --------------------------
if ((t is None) and (S is None) and (E is None) and (I is None) and (R is None)):
t = t_one_step
S = S_one_step
E = E_one_step
I = I_one_step
R = R_one_step
else:
t = np.concatenate((t, (t_one_step + t[-1])), axis=None)
S = np.concatenate((S, S_one_step), axis=None)
E = np.concatenate((E, E_one_step), axis=None)
I = np.concatenate((I, I_one_step), axis=None)
R = np.concatenate((R, R_one_step), axis=None)
# Get prevalence -------------------------------------------------------
curr_prev = (E[-1] + I[-1]) / N
# Get initial conditions for next step of simulation -------------------
nodes_one_step_final = full_net_one_step.get_statuses(list(range(N)), t_one_step[-1])
next_step_IC = defaultdict(lambda: 'S')
for node in range(N):
status = nodes_one_step_final[node]
next_step_IC[node] = status
# Create complete returnable object of simulation --------------------------
to_add = list()
to_add.append(t)
to_add.append(S)
to_add.append(E)
to_add.append(I)
to_add.append(R)
full_net = full_net_one_step
last_time_step_dictionary = full_net.get_statuses(time=full_net.t()[-1])
to_return = [last_time_step_dictionary, to_add, t[-1]]
return to_return
def create_simulation(
sim_name,
sq_rate,
qs_rate,
it_rate,
si_rate,
population_size,
initial_infection_number,
):
matrix_size = int(round(population_size**(0.5)))
G = nx.grid_2d_graph(matrix_size, matrix_size)
initial_infections = [(randint(0, matrix_size), randint(0, matrix_size))
for _ in range(initial_infection_number)]
H = nx.DiGraph()
H.add_edge('Susc', 'Quar', rate=sq_rate)
H.add_edge('Quar', 'Susc', rate=qs_rate)
H.add_edge('Infe', 'Trea', rate=it_rate)
H.add_edge('Trea', 'Quar', rate=0.05)
J = nx.DiGraph()
J.add_edge(('Infe', 'Susc'), ('Infe', 'Infe'), rate=si_rate)
IC = defaultdict(lambda: 'Susc')
for node in initial_infections:
IC[node] = 'Infe'
return_statuses = ['Susc', 'Infe', 'Trea', 'Quar']
sim_kwargs = {
'color_dict': {
'Susc': '#5cb85c',
'Infe': '#d9534f',
'Trea': '#f0ad4e',
'Quar': '#0275d8',
},
'pos': {node: node
for node in G},
'tex': False,
}
sim = EoN.Gillespie_simple_contagion(
G,
H,
J,
IC,
return_statuses,
tmax=150,
return_full_data=True,
sim_kwargs=sim_kwargs,
)
produce_visualization(sim_name, sim, population_size)
convert_video(sim_name)
def run(self, t0, tmax, tsteps, state):
G, IC = state
H, J = self.transitions()
rs = [o["name"] for o in self.observables]
ig = EoN.Gillespie_simple_contagion(G, H, J, IC, rs, tmax = (tmax-t0), return_full_data=True)
nettime, cols = ig.summary()
nettraj = np.vstack(list(cols[o] for o in rs))
nettime += t0
t = np.linspace(t0, tmax, tsteps)
if nettime.shape == (1,):
## can't interpolate if no transitions are possible
traj = np.vstack(list(nettraj.T for _ in range(tsteps))).T
else:
traj = interp1d(nettime, nettraj, kind="previous", bounds_error=False,
fill_value=(nettraj[:,0], nettraj[:,-1]))(t)
return (t, traj.T, (ig.G, ig.get_statuses(time=nettime[-1])))
def run_SEIR(G,
E2I_rate,
trans_rate,
recov_rate,
init_seed_frac,
initially_infected_nodes=None):
N = G.number_of_nodes()
H = nx.DiGraph()
H.add_node("S")
H.add_edge("E", "I", rate=E2I_rate)
H.add_edge("I", "R", rate=recov_rate)
J = nx.DiGraph()
J.add_edge(("I", "S"), ("I", "E"), rate=trans_rate)
IC = defaultdict(lambda: "S")
if initially_infected_nodes is None:
initially_infected_nodes = np.random.choice(
N, np.round(N * init_seed_frac).astype(int), replace=False)
for node in initially_infected_nodes:
IC[node] = "E"
return_statuses = ("S", "E", "I", "R")
sim_data = EoN.Gillespie_simple_contagion(
G,
H,
J,
IC,
return_full_data=True,
return_statuses=return_statuses,
tmax=float("Inf"),
)
return sim_data
J = nx.DiGraph() #the induced transitions
J.add_edge(('Inf', 'Sus'), ('Inf', 'Inf'), rate = 2.0)
IC = defaultdict(lambda:'Sus')
for node in initial_infections:
IC[node] = 'Inf'
return_statuses = ['Sus', 'Inf', 'Rec', 'Vac']
color_dict = {'Sus': '#009a80','Inf':'#ff2000', 'Rec':'gray','Vac': '#5AB3E6'}
pos = {node:node for node in G}
tex = False
sim_kwargs = {'color_dict':color_dict, 'pos':pos, 'tex':tex}
sim = EoN.Gillespie_simple_contagion(G, H, J, IC, return_statuses, tmax=total_simulation_days, return_full_data=True, sim_kwargs=sim_kwargs)
count = 0
while(count < total_simulation_days):
t, S, E, I, R = EoN.Gillespie_simple_contagion(G, H, J, IC, return_statuses, tmax=count, sim_kwargs=sim_kwargs)
new_infected_case = I[-1]
diff = new_infected_case - previous_infected_case
previous_infected_case = new_infected_case
total_infected_case=total_infected_case+diff
count=count+1
total_death=total_death + int(total_infected_case*0.02) #percentage of death based on current data..
print("Current Infected People after vaccine: ", total_infected_case, "/", population*population) ##Number of infected people without vaccine
print("Total Death People after vaccine:", total_death, "/", population*population)
H.add_edge('E', 'I', rate=0.1809, weight_label='expose2infect_weight')
H.add_edge('I', 'R', rate=0.090)
J = nx.DiGraph() # Transmissão induzida
J.add_edge(('I', 'S'), ('I', 'E'),
rate=0.0933,
weight_label='transmission_weight')
IC = defaultdict(lambda: 'S')
for node in range(50):
IC[node] = 'I'
return_statuses = ('S', 'E', 'I', 'R')
print('Realizando a simulação de Gillespie')
t, S, E, I, R = EoN.Gillespie_simple_contagion(G,
H,
J,
IC,
return_statuses,
tmax=float(150))
# Pega dados reais
result = pd.read_csv('arquivos/CovidCE.csv', sep=';')
# print(result)
# print(result.values.transpose()[0])
# print(result.values.transpose()[1])
# ----------------------------------
# Salva dados em csv Simulação_COVID
# ----------------------------------
Ob = np.array(0.065 * (R + I))
Ob = np.around(Ob)
J.add_edge(('II', 'RS'), ('II', 'RI'), rate = 0.2)
J.add_edge(('RI', 'SS'), ('RI', 'SI'), rate = 1)
J.add_edge(('RI', 'IS'), ('RI', 'II'), rate = 1)
J.add_edge(('RI', 'RS'), ('RI', 'RI'), rate = 1)
J.add_edge(('IS', 'SS'), ('IS', 'IS'), rate = 0.2)
J.add_edge(('IS', 'SI'), ('IS', 'II'), rate = 0.2)
J.add_edge(('IS', 'SR'), ('IS', 'IR'), rate = 0.2)
J.add_edge(('II', 'SS'), ('II', 'IS'), rate = 0.2)
J.add_edge(('II', 'SI'), ('II', 'II'), rate = 0.2)
J.add_edge(('II', 'SR'), ('II', 'IR'), rate = 0.2)
J.add_edge(('IR', 'SS'), ('IR', 'IS'), rate = 1)
J.add_edge(('IR', 'SI'), ('IR', 'II'), rate = 1)
J.add_edge(('IR', 'SR'), ('IR', 'IR'), rate = 1)
return_statuses = ('SS', 'SI', 'SR', 'IS', 'II', 'IR', 'RS', 'RI', 'RR')
initial_size = 700
IC = defaultdict(lambda: 'SS')
for node in range(initial_size):
IC[node] = 'II'
t, SS, SI, SR, IS, II, IR, RS, RI, RR = EoN.Gillespie_simple_contagion(G, H, J, IC, return_statuses,
tmax = float('Inf'))
plt.semilogy(t, IS+II+IR, '-.', label = 'Infected with disease 1')
plt.semilogy(t, SI+II+RI, '-.', label = 'Infected with disease 2')
plt.legend()
plt.savefig('Cooperate.png')
return_statuses = ['Sus', 'Inf', 'Rec', 'Vac']
color_dict = {
'Sus': '#009a80',
'Inf': '#ff2000',
'Rec': 'gray',
'Vac': '#5AB3E6'
}
pos = {node: node for node in G}
tex = False
sim_kwargs = {'color_dict': color_dict, 'pos': pos, 'tex': tex}
sim = EoN.Gillespie_simple_contagion(G,
H,
J,
IC,
return_statuses,
tmax=30,
return_full_data=True,
sim_kwargs=sim_kwargs)
#Esto no maneja contagios complejos. Se asume que cuando un individuo cambia de estado, ha recibido una “transmisión” de un solo vecino o está cambiando de estado independientemente de los vecinos. Entonces esto es como SIS o SIR.
#EoN.Gillespie_simple_contagion(G, spontaneous_transition_graph, nbr_induced_transition_graph, IC, return_statuses, tmin=0, tmax=100, spont_kwargs=None, nbr_kwargs=None, return_full_data=False, sim_kwargs=None)
#spontaneous_transition_graph:contagios espontaneos, nbr_induced_transition_graph: transiciones inducidas por vecinos, IC:establece el estado inicial de cada nodo en la red.
times, D = sim.summary()
#
#imes is a numpy array of times. D is a dict, whose keys are the entries in
#return_statuses. The values are numpy arrays giving the number in that
#status at the corresponding time.
newD = {
'Sus+Vac': D['Sus'] + D['Vac'],
def add_relaxation(input_net, H, J, initial_conditions,
t, S, E, I, R,
unfuse,
fused_edges_dict,
length_sim):
net = input_net.copy()
# If unfuse, perhaps tedious, but have not found a better way to do it:
# check every day for infectious persons in the graph. ---------------------
if unfuse:
next_step_IC = initial_conditions
save_last_R = 0
while not ((E[-1] == 0 and I[-1] == 0 and R[-1] == save_last_R)):
save_last_R = R[-1]
# Run for one time step --------------------------------------------
full_net_one_step = EoN.Gillespie_simple_contagion(net, H, J, next_step_IC, return_statuses, tmax = 1, return_full_data=True)
t_one_step = full_net_one_step.t()
S_one_step = full_net_one_step.S()
E_one_step = full_net_one_step.summary()[1]['E']
I_one_step = full_net_one_step.I()
R_one_step = full_net_one_step.R()
# Concatenate results of the single time step ----------------------
t = np.concatenate((t, (t_one_step + t[-1])), axis=None)
S = np.concatenate((S, S_one_step), axis=None)
E = np.concatenate((E, E_one_step), axis=None)
I = np.concatenate((I, I_one_step), axis=None)
R = np.concatenate((R, R_one_step), axis=None)
# Get list of nodes that are infectious at the end of this time step
# as well as get initial conditions for next step of simulation ----
nodes_one_step_final = full_net_one_step.get_statuses(list(range(N)), t_one_step[-1])
next_step_IC = defaultdict(lambda: 'S')
symptomatic_nodes = []
for node in range(N):
status = nodes_one_step_final[node]
next_step_IC[node] = status
if status == "I":
symptomatic_nodes.append(node)
# Run unfuse method ------------------------------------------------
net = unfuse_graph(input_graph=net,
symptomatic_nodes=symptomatic_nodes,
fused_edges_dict=fused_edges_dict,
prob_unfuse=prob_unfuse)
# Create complete returnable object of simulation ----------------------
to_add = list()
to_add.append(t)
to_add.append(S)
to_add.append(E)
to_add.append(I)
to_add.append(R)
full_net = full_net_one_step
else:
full_net = EoN.Gillespie_simple_contagion(net, H, J, initial_conditions, return_statuses, tmax = length_sim, return_full_data=True)
t_net = full_net.t()
S_net = full_net.S()
E_net = full_net.summary()[1]['E']
I_net = full_net.I()
R_net = full_net.R()
t = np.concatenate((t, (t_net + t[-1])), axis = None)
S = np.concatenate((S, S_net), axis=None)
E = np.concatenate((E, E_net), axis=None)
I = np.concatenate((I, I_net), axis=None)
R = np.concatenate((R, R_net), axis=None)
to_add = list()
to_add.append(t)
to_add.append(S)
to_add.append(E)
to_add.append(I)
to_add.append(R)
last_time_step_dictionary = full_net.get_statuses(time=full_net.t()[-1])
to_return = [last_time_step_dictionary, to_add]
return to_return
returned_run_until_prev = run_until_prev(input_net=O, H=H, J=J, initial_conditions=IC,
prev_start_SD=prev_start_SD)
t_O = returned_run_until_prev[1][0]
S_O = returned_run_until_prev[1][1]
E_O = returned_run_until_prev[1][2]
I_O = returned_run_until_prev[1][3]
R_O = returned_run_until_prev[1][4]
nodes_O_final = returned_run_until_prev[0]
SD_day = returned_run_until_prev[2]
SD_days.append(SD_day)
# Next, run on the SD graph ------------------------------------------------
SD_IC = defaultdict(lambda: 'S')
for node in range(N):
SD_IC[node] = nodes_O_final[node]
full_SD = EoN.Gillespie_simple_contagion(SD, H, J, SD_IC, return_statuses, tmax = sd_to_easing, return_full_data=True)
t_SD = full_SD.t()
S_SD = full_SD.S()
E_SD = full_SD.summary()[1]['E']
I_SD = full_SD.I()
R_SD = full_SD.R()
nodes_SD_final = full_SD.get_statuses(list(range(N)), t_SD[-1])
# Next, run on the added_frac_long_SD graph --------------------------------
expanded_SD_IC = defaultdict(lambda: 'S')
for node in range(N):
expanded_SD_IC[node] = nodes_SD_final[node]
full_expanded_SD = EoN.Gillespie_simple_contagion(added_frac_long_SD, H, J, expanded_SD_IC, return_statuses, tmax=easing_to_evictions, return_full_data=True)
t_expanded_SD = full_expanded_SD.t()
S_expanded_SD = full_expanded_SD.S()
E_expanded_SD = full_expanded_SD.summary()[1]['E']
H.add_node('S')
H.add_edge('E', 'I', rate=0.6,
weight_label='expose2infect_weight') #speed is 0.6*weight
H.add_edge('I', 'R', rate=0.01)
# Neighbor-dependent Transitions
J = nx.DiGraph()
J.add_edge(('I', 'S'), ('I', 'E'),
rate=0.5,
weight_label='transmission_weight')
## Set Initial Conditions
IC = defaultdict(lambda: 'S')
random_infected = random.sample(list(G.nodes), k=1)
for node in random_infected:
IC[node] = 'I'
return_statuses = ('S', 'E', 'I', 'R')
epidemic = EoN.Gillespie_simple_contagion(G,
H,
J,
IC,
return_statuses,
tmax=float('Inf'),
return_full_data=True)
# Simple sample plotting
plt.plot(epidemic.t(), epidemic.I())
plt.savefig('epidemic_curve.png')
return scale
def return_to_susceptibility_weighting(G, node, **kwargs):
scale = 1
if G.node[node]['gender'] is 'F':
scale *= 0.5
return scale
H = nx.DiGraph() #DiGraph showing possible transitions that don't require an interaction
H.add_edge('I', 'R', rate = 1.4, rate_function=recovery_weighting) #I->R
H.add_edge('R', 'S', rate = 0.2, rate_function = return_to_susceptibility_weighting) #R->S
J = nx.DiGraph() #DiGraph showing transition that does require an interaction.
J.add_edge(('I', 'S'), ('I', 'I'), rate = 1, rate_fuction = transmission_weighting) #IS->II
IC = defaultdict(lambda: 'S')
for node in range(200):
IC[node] = 'I'
return_statuses = ('S', 'I', 'R')
age_cutoff = 18
t, S, I, R = EoN.Gillespie_simple_contagion(G, H, J, IC, return_statuses, tmax = 30,
spont_kwargs = {'age_cutoff':age_cutoff},
nbr_kwargs = {'age_cutoff':age_cutoff})
plt.plot(t, S, label = 'Susceptible')
plt.plot(t, I, label = 'Infected')
plt.plot(t, R, label = 'Recovered')
plt.legend()
plt.savefig('SIRS_heterogeneous.png')
