def process_degree_distribution(N, Pk, color, Psi, DPsi, symbol, label, count):
report_times = scipy.linspace(0, 30, 3000)
sums = 0 * report_times
for cnt in range(count):
G = generate_network(Pk, N)
t, S, I, R = EoN.fast_SIR(G, tau, gamma, rho=rho)
plt.plot(t, I * 1. / N, '-', color=color, alpha=0.1, linewidth=1)
subsampled_I = EoN.subsample(report_times, t, I)
sums += subsampled_I * 1. / N
ave = sums / count
plt.plot(report_times, ave, color='k')
#Do EBCM
N = G.order(
) #N is arbitrary, but included because our implementation of EBCM assumes N is given.
t, S, I, R = EoN.EBCM_uniform_introduction(N,
Psi,
DPsi,
tau,
gamma,
rho,
tmin=0,
tmax=10,
tcount=41)
plt.plot(t, I / N, symbol, color=color, markeredgecolor='k', label=label)
for cnt in range(3): #do 3 highlighted simulations
G = generate_network(Pk, N)
t, S, I, R = EoN.fast_SIR(G, tau, gamma, rho=rho)
plt.plot(t, I * 1. / N, '-', color='k', linewidth=0.1)
def process_degree_distribution(Gbig, Gsmall, color, Psi, DPsi, symbol):
t, S, I, R = EoN.fast_SIR(Gsmall, tau, gamma, rho=rho)
plt.plot(t, I * 1. / Gsmall.order(), ':', color=color)
t, S, I, R = EoN.fast_SIR(Gbig, tau, gamma, rho=rho)
plt.plot(t, I * 1. / Gbig.order(), color=color)
N = Gbig.order(
) #N is arbitrary, but included because our implementation of EBCM assumes N is given.
t, S, I, R = EoN.EBCM(N, lambda x: (1 - rho) * Psi(x), lambda x:
(1 - rho) * DPsi(x), tau, gamma, 1 - rho)
I = EoN.subsample(report_times, t, I)
plt.plot(report_times, I / N, symbol, color=color, markeredgecolor='k')
def run_epidemics(G, tau, gamma, weight, num_init, perc_infec, full=False):
'''
'''
time = None
nodes = list(G.nodes())
n_nodes = len(nodes)
n_iter = 0
while time is None:
np.random.shuffle(nodes)
full_data = EoN.fast_SIR(G, tau, gamma, initial_infecteds=nodes[0:num_init],
transmission_weight=weight, return_full_data=True)
infec = full_data.I()
recov = full_data.R()
for i in range(infec.shape[0]):
if infec[i] + recov[i] >= perc_infec * n_nodes:
time = full_data.t()[i]
break
n_iter += 1
if n_iter > 1000:
print("Could not reach desired infection rate after 1000 iterations")
return None
if full is True:
return full_data
else:
return full_data.get_statuses(time=time)
def epidemy_with_recover(graph,
initial_nodes,
transmission_rate,
recovery_rate,
plot_tittle='',
return_full_data=False):
if return_full_data:
return EoN.fast_SIR(graph,
transmission_rate,
gamma=recovery_rate,
initial_infecteds=initial_nodes,
return_full_data=return_full_data)
else:
t, S, I, R = EoN.fast_SIR(graph,
transmission_rate,
gamma=recovery_rate,
initial_infecteds=initial_nodes)
max_time_index = 0
biggest_number_infected = 0
for i in range(0, len(I)):
if I[i] > biggest_number_infected:
print(f'Infectados:{I[i]} = Limiar:{biggest_number_infected}')
biggest_number_infected = I[i]
max_time_index = i
t = t * 100
plt.title(plot_tittle)
plt.plot(t, I, label='Infectados')
plt.plot(t, S, label='Suscetivel')
plt.plot(t, R, label='Removidos')
plt.hlines(I[max_time_index], t[0], t[max_time_index], colors='k')
plt.vlines(t[max_time_index], I[0], I[max_time_index], colors='k')
plt.xlim(0, max(t))
plt.ylim(0, graph.number_of_nodes())
plt.xticks([t[max_time_index]])
plt.yticks([I[max_time_index]])
plt.legend(loc='best')
plt.show()
def SIR_process(G, degree_prob, tau, gamma, tmax=10):
N = G.order()
plt.figure(2)
plt.clf()
plt.figure(3)
plt.clf()
plt.figure(5)
plt.clf()
for index, starting_node in enumerate([x * N / 100. for x in range(100)]):
plt.figure(2)
t, S, I, R = EoN.fast_SIR(G,
tau,
gamma,
initial_infecteds=[starting_node])
subt = scipy.linspace(0, t[-1], 101)
subI, subR = EoN.subsample(subt, t, I, R)
plt.plot(subt, subI)
if R[-1] > 500:
plt.figure(3)
shift = EoN.get_time_shift(t, R, threshold)
plt.plot(subt - shift, subI)
plt.figure(5)
plt.plot(subt - shift, subR)
#t, S, I, R = EoN.EBCM(degree_prob, tau, gamma, rho)
rho = 1. / N
def psi(x):
return sum(degree_prob[k] * x**k for k in degree_prob)
def psiPrime(x):
return sum(k * degree_prob[k] * x**(k - 1) for k in degree_prob)
t, S, I, R = EoN.EBCM_uniform_introduction(N,
psi,
psiPrime,
tau,
gamma,
rho,
tmax=tmax)
shift = EoN.get_time_shift(t, R, threshold)
plt.figure(2)
#plt.savefig('sw_SIR_epi_N{}_p{}_k{}_tau{}.pdf'.format(N,p,k,tau))
plt.figure(3)
plt.plot(t - shift, I, '--')
plt.xlabel('$t$', fontsize=18)
plt.ylabel('$I$', fontsize=18)
#plt.set_xtick_labels(fontsize = 15)
xmax = get_xmax(t - shift, I)
plt.axis(xmax=xmax)
plt.savefig('sw_SIR_epi_N{}_p{}_k{}_tau{}_shifted.pdf'.format(
N, p, k, tau))
plt.figure(5)
plt.plot(t - shift, R, '--')
def simulateGraph(clusteringAlg, params, full_data=False):
record.print('\n')
record.print(
"building populace into graphs with the {} clustering algorithm".
format(clusteringAlg.__name__))
start = time.time()
graph = nx.Graph()
clusterGroups(graph, 'sp_hh_id', homeInfectivity, clusterDenseGroup)
record.print("{} weights of size {} have been added for {} homes".format(
graph.size(), 1, len(popsByCategory['sp_hh_id'].keys())))
clusterGroups(graph, 'work_id', workInfectivity, clusteringAlg, params)
clusterGroups(graph, 'school_id', workInfectivity, clusteringAlg, params)
stop = time.time()
record.print(
"The final graph finished in {} seconds. with properties:".format(
(stop - start)))
record.print("{edges: {}, nodes: }".format(graph.size()))
return (graph)
record.print("running event-based simulation")
if full_data:
simResult = EoN.fast_SIR(graph,
globalInfectionRate,
recoveryRate,
rho=0.0001,
transmission_weight='transmission_weight',
return_full_data=True)
else:
simResult = EoN.fast_SIR(graph,
globalInfectionRate,
recoveryRate,
rho=0.0001,
transmission_weight='transmission_weight',
return_full_data=False)
stop = time.time()
record.print("finished in {} seconds".format(stop - start))
return simResult
def epidemy_without_recover(graph,
initial_nodes,
transmission_rate,
plot_tittle='',
return_full_data=False):
if return_full_data:
return EoN.fast_SIR(graph,
transmission_rate,
gamma=0,
initial_infecteds=initial_nodes,
return_full_data=return_full_data)
else:
t, S, I, R = EoN.fast_SIR(graph,
transmission_rate,
gamma=0,
initial_infecteds=initial_nodes)
max_time_index = 0
for i in range(0, len(I)):
if I[i] > 0.9 * graph.number_of_nodes():
print(
f'Infectados:{I[i]} = Limiar:{0.9*graph.number_of_nodes()}'
)
max_time_index = i
break
t = t * 100
plt.plot(t, I, label=plot_tittle)
#plt.plot(t, S, label='Suscetivel', color='b')
#plt.hlines(I[max_time_index], t[0], t[max_time_index], colors='k')
#plt.vlines(t[max_time_index], I[0], I[max_time_index], colors='k')
#plt.xticks([t[max_time_index]])
#plt.yticks([I[max_time_index]])
plt.legend(loc='best')
def network_SIR_finalsize_lambda_sensitivity(G, mu, rho, lambda_min,
lambda_max, nruns):
#average_degree = 2 * G.number_of_edges() / G.number_of_nodes()
#lc = mu / average_degree
final_size = defaultdict(list) # normalized attack rate
for lambd in np.geomspace(lambda_min, lambda_max, nruns):
for run in range(0, nruns):
t, S, I, R = EoN.fast_SIR(G, tau=lambd, gamma=mu, rho=rho)
final_size[lambd].append(R[-1] / G.number_of_nodes())
return pd.DataFrame.from_dict(final_size)
def sim_and_plot(G, tau, gamma, rho, tmax, tcount, ax):
t, S, I, R= EoN.fast_SIR(G, tau, gamma, rho = rho, tmax = tmax)
report_times = scipy.linspace(0, tmax, tcount)
I = EoN.subsample(report_times, t, I)
ax.plot(report_times, I/N, color='grey', linewidth=5, alpha=0.3)
t, S, I, R = EoN.SIR_heterogeneous_meanfield_from_graph(G, tau, gamma, rho=rho,
tmax=tmax, tcount=tcount)
ax.plot(t, I/N, '--')
t, S, I, R = EoN.SIR_compact_pairwise_from_graph(G, tau, gamma, rho=rho,
tmax=tmax, tcount=tcount)
ax.plot(t, I/N)
t, S, I, R = EoN.SIR_homogeneous_pairwise_from_graph(G, tau, gamma, rho=rho,
tmax=tmax, tcount=tcount)
ax.plot(t, I/N, '-.')
def run_sir(G, dt, sir_params, state):
"""
Run simulation for time dt
Parameters
----------
sim_params : dict
Parameter for the fast_SIR
state : State
state of SIR simulation
Returns
-------
sim_data : simulation data
state : dict
the state object after running simulation for dt
"""
sir_params["tmax"] = dt
sim_data = EoN.fast_SIR(G,
return_full_data=True,
initial_infecteds=state.infected,
initial_recovereds=state.recovered +
state.isolated,
**sir_params)
# Update node state
node_state = sim_data.get_statuses(G.nodes(), dt)
infected = [k for k, v in node_state.items() if v == "I"]
recovered = [k for k, v in node_state.items() if v == "R"]
state.infected = infected
state.recovered = list(set(recovered) - set(state.isolated))
# Update the transimission tree
trans_tree = sim_data.transmission_tree()
trans_tree_old = state.trans_tree
if trans_tree_old is None:
state.trans_tree = trans_tree
else:
base_t = state.t
for eds in trans_tree.edges(data=True):
tt = eds[2]["time"] + base_t
trans_tree_old.add_edge(eds[0], eds[1], time=tt)
state.trans_tree = trans_tree_old
# Tick time
return sim_data, state
t0 = 2
t1 = 4
tmax = 8
gamma = 1
tau0 = 1
tau1 = 0.5
N = 1000000
kave = 4
rho = 0.001
G = nx.fast_gnp_random_graph(N, kave / (N - 1.))
times0, S0, I0, R0, infection_time, recovery_time = EoN.fast_SIR(
G, tau0, gamma, rho=rho, tmax=t0, return_full_data=True)
infected, recovered = get_affected_nodes_at_end(infection_time, recovery_time)
times1, S1, I1, R1, infection_time, recovery_time = EoN.fast_SIR(
G,
tau0,
gamma,
initial_infecteds=infected,
initial_recovereds=recovered,
tmin=t0,
tmax=t1,
return_full_data=True)
infected, recovered = get_affected_nodes_at_end(infection_time, recovery_time)
iterations = 200
rho = 0.05
tmax = 15
tcount = 1001
report_times = scipy.linspace(0, tmax, tcount)
ax1 = plt.gca() #axes([0.1,0.1,0.9,0.9])
ax2 = plt.axes([0.44, 0.45, 0.4, 0.4])
for kave, ax in zip((50, 5), (ax1, ax2)):
tau = 2 * gamma / kave
Isum = scipy.zeros(tcount)
for counter in range(iterations):
G = nx.configuration_model(N * [kave])
t, S, I, R = EoN.fast_SIR(G, tau, gamma, tmax=tmax, rho=rho)
I = I * 1. / N
I = EoN.subsample(report_times, t, I)
Isum += I
ax.plot(report_times,
Isum / iterations,
color='grey',
linewidth=5,
alpha=0.3)
S0 = (1 - rho) * N
I0 = rho * N
R0 = 0
t, S, I, R = EoN.SIR_homogeneous_meanfield(S0,
I0,
for edge in G.edges():
G.edges[edge[0], edge[1]]['weight'] = G.nodes[
edge[0]]['safety'] * G.nodes[edge[1]]['safety']
weight_sum += G.nodes[edge[0]]['safety'] * G.nodes[
edge[1]]['safety']
tmax = 20
iterations = 1 #run 5 simulations
tau = 0.1 #transmission rate
gamma = 1.0 #recovery rate
rho = 0.01 #random fraction initially infected
sim = EoN.fast_SIR(G,
G.number_of_edges() / weight_sum,
gamma,
rho=rho,
transmission_weight='weight',
tmax=tmax,
return_full_data=True)
# ani = sim.animate(ts_plots=['I', 'SIR'])
# filename = "smallworld_animation_for_comparison.mp4"
# ani.save(filename, extra_args=['-vcodec', 'libx264'])
# plt.figure()
# plt.suptitle('Safety Skew ' + str(avg_safety))
plt.subplot(len(safety_generator_list) + 1, 2, 3 + 2 * s)
plt.title('Total Infections; Safety = ' + str(avg_safety))
plt.xlabel('$t$')
# plt.ylabel('Number infected')
plt.plot(sim.t(),
sim.I(),
def simulation(G, tau, gamma, rho, max_time, number_infected_before_release, release_number, background_inmate_turnover,
stop_inflow_at_intervention, p, death_rate, percent_infected, percent_recovered, social_distance,
social_distance_tau, initial_infected_list):
"""Runs a simulation on SIR model.
Args:
G: Networkx graph
tau: transmission rate
gamma: recovery rate
rho: percent of inmates that are initially infected
max_time: # of time steps to run simulation
number_infected_before_release: number of infected at which to perform release on next integer time
release_number: # of inmates to release at release intervention
background_inmate_turnover: background # of inmates added/released at each time step
stop_inflow_at_intervention: should we stop the background inflow of inmates at intervention time?
p: probability of contact between inmate and other inmates
death_rate: percent of recovered inmates that die
percent_infected: percent of general population that is infected
percent_recovered: percent of general population that is recovered
social_distance: boolean flag, if we lower transmission rate after major release
social_distance_tau: new transmission rate after major release
initial_infected_list: sets node numbers of initial infected (default is 0, this parameter is arbitrary)
Returns:
t: array of times at which events occur
S: # of susceptible inmates at each time
I: # of infected inmates at each time
R: # of recovered inmates at each time
D: # of dead inmates at each time step
"""
print('Starting simulation...')
release_occurred = False
background_release_number = background_inmate_turnover
data_list = []
recovered_list = []
delta_recovered_list = []
# Check we are using initial_infected_list
if initial_infected_list is not None:
print('Using initial infected list to set initial infected.')
infected_list = initial_infected_list.copy()
else: # Choose random initial infections based on rho
print('Using rho to set initial infected.')
infected_list = list(np.random.choice(list(G.nodes), int(np.ceil(rho * len(G.nodes))), replace=False))
# Loop over time
for i in range(max_time):
# Run 1 time unit of simulation
data = EoN.fast_SIR(G, tau, gamma, initial_infecteds=infected_list, initial_recovereds=recovered_list,
tmin=i, tmax=i + 1, return_full_data=True)
data_list.append(data)
# Update infected and recovered inmate lists
infected_list, recovered_list = get_infected(data, i + 1), get_recovered(data, i + 1)
# Check if release condition has been met
if not release_occurred and len(infected_list) >= number_infected_before_release:
background_inmate_turnover, r_n, tau = enact_interventions(background_inmate_turnover,
background_release_number, i + 1,
infected_list, release_number,
social_distance,
social_distance_tau,
stop_inflow_at_intervention,
tau)
release_occurred = True
else: # If not, use background release rate
r_n = background_release_number
# Add and release inmates
G, infected_list, recovered_list, delta_recovered = recalibrate_graph(G, infected_list, recovered_list,
background_inmate_turnover, r_n, p,
percent_infected, percent_recovered,
death_rate)
# Track the number of recovered inmates added or released at each time step
delta_recovered_list.append(delta_recovered)
# Process raw data into t, S, I, R, D arrays
t, S, I, R, D = process_data(data_list, delta_recovered_list, death_rate)
print('Simulation completed.\n')
return t, S, I, R, D
tau = 0.3 # transmission rate
gamma = 1.0 # recovery rate
#tau = 3 # transmission rate
#gamma = 1.0 # recovery rate
print("tau= %f, gamma= %f" % (tau, gamma))
kave = 120 # expected number of partners
print("generating graph G with {} nodes".format(N))
G = nx.fast_gnp_random_graph(N, kave / (N - 1)) #Erdo’’s-Re’nyi graph
nb_edges = len(G.edges)
print("Initial number of infected: %f, fraction infected: %f" % (rho * N, rho))
print("graph has {} edges".format(nb_edges))
print("doing event-based simulation")
t = time.time()
t1, S1, I1, R1 = EoN.fast_SIR(G, tau, gamma, rho=rho)
elapsed_time = time.time() - t
print("Total time to compute: ", elapsed_time, " sec")
#print("doing Gillespie simulation")
#t2, S2, I2, R2 = EoN.Gillespie_SIR(G, tau, gamma, rho=rho)
print("done with simulations, now plotting")
plt.plot(t1, I1, label="fast_SIR")
#plt.plot(t2, I2, label = "Gillespie_SIR")
plt.plot(t1, R1)
#plt.plot(t2, R2)
plt.plot(t1, S1)
#plt.plot(t2, S2)
plt.xlabel("$t$")
plt.xlabel("Number infected")
import networkx as nx
import EoN
import matplotlib.pyplot as plt
G = nx.grid_2d_graph(100, 100) #each node is (u,v) where 0<=u,v<=99
#we'll initially infect those near the middle
initial_infections = [(u, v) for (u, v) in G if 45 < u < 55 and 45 < v < 55]
pos = {node: node for node in G}
sim_kwargs = {'pos': pos}
sim = EoN.fast_SIR(G,
2.0,
1.0,
initial_infecteds=initial_infections,
tmax=40,
return_full_data=True,
sim_kwargs=sim_kwargs)
ani = sim.animate(ts_plots=['I', 'SIR'], node_size=4)
ani.save('SIR_2dgrid.mp4', fps=5, extra_args=['-vcodec', 'libx264'])
a * maximum
) # NOTE: Shouldn't this use len(L) instead of maximum????
for x in range(a):
edge = random.choice(L)
G.add_edge(edge[0], edge[1])
edges3.append(edge)
L.remove(edge)
tmax = 40
print('finished')
SIR = EoN.fast_SIR(G,
tau,
gamma,
initial_infecteds=random.sample(
list(range(maximum)),
math.floor(rho * maximum)),
tmax=tmax,
return_full_data=True)
SIR.display(time=5)
plt.show()
for c in edges3:
G.remove_edge(c[0], c[1])
t, d = SIR.summary()
max_infected = max(d['I'])
total_infected = max(d['R'])
time_to_peak = t[np.where(d['I'] == max(d['I']))]
print('max infected= ', max_infected)
print('total infected= ', total_infected)
#function to create homogeneous group
def groupCitizens(graph, citizens, weight):
groupSize = len(citizens)
for i in range(groupSize):
for j in range(i):
graph.add_edge(citizens[j],citizens[i],transmission_weight = weight)
#link population in the same households
citizenHouses = list(zip(citizens,houseNumbers))
for i in range(houseHolds):
house = list(zip(*list(filter(lambda x: (x[1]==i),citizenHouses))))[0]
groupCitizens(graph, house, houseInfectivity)
#link population in the same work environmen
assignmentGroups = list(zip(citizens, assignments))
for i in range(environmentCount):
environmentGroup = list(zip(*list(filter(lambda x:(x[1]==i),assignmentGroups))))[0]
groupCitizens(graph, environmentGroup, workInfectivity)
nx.draw(graph)
plt.show()
for i in range(epidemicSims):
t,S,I,R = EoN.fast_SIR(graph, globalInfectionRate, recoveryRate, rho = 0.01, transmission_weight ='transmission_weight')
plt.plot(t,R)
plt.plot(t,I)
plt.plot(t,S)
plt.xlabel("time")
plt.ylabel("citizens")
plt.show()
#creats node for each student in the school#
for x in range(students):
G.add_node(x)
time=0
infected=[]
recovered=[]
#this is where the 'school day' starts#
for period in range(periods*days):
if (period/periods==int(period/periods)) and (counter!=0):
SIR=EoN.fast_SIR(G, 0, gamma, tmin=tmin, tmax = 16, initial_infecteds=infected, initial_recovereds=recovered, return_full_data=True)
t,d=SIR.summary()
time += 16
node_stats=list(SIR.get_statuses(nodelist=None, time=32).values())
#creates list of infecteds and recoverds after each iteration to feed into the next#
final_infected=[]
for i in range(len(node_stats)):
if node_stats[i]=='I':
infected.append(i)
final_infected.append(i)
elif node_stats[i]=='R':
recovered.append(i)
groupCitizens(graph, house, houseInfectivity)
#link population in the same work environmen
assignmentGroups = list(zip(citizens, assignments))
for i in range(environmentCount):
environmentGroup = list(
zip(*list(filter(lambda x: (x[1] == i), assignmentGroups))))[0]
groupCitizens(graph, environmentGroup, workInfectivity)
end = time.time()
printAndRecord(end - start)
start = time.time()
#for i in range(epidemicSims):
node_investigation = EoN.fast_SIR(graph,
globalInfectionRate,
recoveryRate,
rho=0.01,
transmission_weight='transmission_weight',
return_full_data=True)
plt.plot(node_investigation.summary(students)[1]['I'],
label="infected students")
plt.plot(node_investigation.summary(working)[1]['I'], label="infected workers")
plt.plot(node_investigation.summary(unemployed)[1]['I'],
label="infected unemployed")
plt.legend()
plt.show()
#plt.plot(t,R)
#plt.plot(t,I)
#plt.plot(t,S)
#plt.show()
end = time.time()
printAndRecord(end - start)
L = [edge for edge in L if edge not in edges]
edge_list = random.sample(L, math.floor(a * total_pop))
G.add_edges_from(edge_list)
edge_list = random.sample(L, math.floor(a * total_pop))
G.add_edges_from(edge_list)
started = False
for i in range(iterations):
#Running the simulation
sim = e.fast_SIR(G,
tau,
gamma,
initial_infecteds=infecteds,
initial_recovereds=recovereds,
tmax=time_reading,
return_full_data=True)
statuses = list(sim.get_statuses(time=time_reading).values())
#sim.display(time=time_reading)
#plt.show()
infecteds = []
recovereds = []
#Storing infected and recovered node info for next graph
for j in range(len(statuses)):
if statuses[j] == 'I':
infecteds.append(j)
if statuses[j] == 'R':
recovereds.append(j)
import EoN
import networkx as nx
import matplotlib.pyplot as plt
from collections import defaultdict
N = 1000
gamma = 1
tau = 1.5 / N
G = nx.complete_graph(N)
iterations = 10000
binwidth = 10
H = defaultdict(int)
for counter in range(iterations):
t, S, I, R = EoN.fast_SIR(G, tau, gamma)
H[binwidth * (R[-1] / binwidth)] = H[binwidth *
(R[-1] / binwidth)] + 1. / iterations
fig = plt.figure(1)
main = plt.axes()
main.bar(*zip(*H.items()), width=binwidth, linewidth=0)
main.axis(xmax=1000, ymax=0.7)
plt.xlabel('Final Epidemic Size')
plt.ylabel('Frequency')
inset = plt.axes([0.3, 0.3, 0.5, 0.5])
inset.bar(*zip(*H.items()), width=binwidth, linewidth=0)
inset.axis(xmin=300, xmax=900, ymin=0, ymax=0.03)
groups[day].append(list(new_class))
group_students = list(
set(group_students).difference(set(new_class))
) # Removes nodes, as they are added to classes to prevent node being present in multiple classes.
# Creates complete graph for each class
for student_1 in groups[day][class_x]:
for student_2 in groups[day][class_x]:
G.add_edge(student_1, student_2)
# Running the simulation
if started == False:
started = True
sim = e.fast_SIR(G,
tau,
gamma,
rho=rho,
initial_recovereds=recovered,
return_full_data=True,
tmax=time_reading)
else:
sim = e.fast_SIR(G,
tau,
gamma,
initial_infecteds=infected,
initial_recovereds=recovered,
return_full_data=True,
tmax=time_reading)
# Runs simulation
# Retrieves node statuses as given time of 'time_reading'
import random
N = 10**6
tau = 1.
gamma = 1.
colors = [
'#5AB3E6', '#FF2000', '#009A80', '#E69A00', '#CD9AB3', '#0073B3', '#F0E442'
]
kave = 5
G = nx.fast_gnp_random_graph(N, kave / (N - 1.))
initial_infecteds = random.sample(range(N), int(0.01 * N))
print('simulating')
t, S, I, R = EoN.fast_SIR(G, tau, gamma, initial_infecteds=initial_infecteds)
report_times = scipy.linspace(0, 10, 101)
S, I, R = EoN.subsample(report_times, t, S, I, R)
plt.plot(report_times, S, color=colors[1], label='simulation')
plt.plot(report_times, I, color=colors[1])
plt.plot(report_times, R, color=colors[1])
print('doing ODE models')
t, S, I, R = EoN.SIR_effective_degree_from_graph(
G, tau, gamma, initial_infecteds=initial_infecteds, tmax=10, tcount=51)
plt.plot(t, S, color=colors[2], dashes=[6, 6], label='effective degree')
plt.plot(t, I, color=colors[2], dashes=[6, 6])
plt.plot(t, R, color=colors[2], dashes=[6, 6])
G = nx.grid_2d_graph(population,population) #each node is (u,v) where 0<=u,v<=99
#we'll initially infect those near the middle
initial_infections = [(u,v) for (u,v) in G if 545<u<555 and 545<v<555] #Cluster of population usually at middle
##-----------------------------------Without Vaccine---------------------------------------------------
#Transmission and Death rate is from here https://www.worldometers.info/coronavirus/
trans_rate = 4.0
recovery_rate = 0.3
total_simulation_days = 15 #30days without vaccine and 30 days with vaccine = 60days sim
death_rate = 0.02
print("Duration: ",total_simulation_days)
print("Module SIR: TransRate: ", trans_rate,", DeathRate: ", death_rate, "%, RecoveryRate: ", recovery_rate, "%")
pos = {node:node for node in G}
sim_kwargs = {'pos': pos}
sim = EoN.fast_SIR(G, trans_rate, recovery_rate, initial_infecteds = initial_infections,
tmax = total_simulation_days, return_full_data=True, sim_kwargs = sim_kwargs)
count = 1
total_death = 0
total_infected_case = 0
previous_infected_case = 0
new_infected_case = 0
while(count < total_simulation_days):
t, S, I, R= EoN.fast_SIR(G, trans_rate, recovery_rate, initial_infecteds = initial_infections,
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
N = 10**5
G = nx.barabasi_albert_graph(N, 5) #create a barabasi-albert graph
# In[5]:
tmax = 20
iterations = 5 #run 5 simulations
tau = 0.1 #transmission rate
gamma = 1.0 #recovery rate
rho = 0.005 #random fraction initially infected
# In[6]:
# Simulations and Models
for counter in range(iterations): #run simulations
t, S, I, R = EoN.fast_SIR(G, tau, gamma, rho=rho, tmax=tmax)
if counter == 0:
plt.plot(t, I, color='k', alpha=0.3, label='Simulation')
plt.plot(t, I, color='k', alpha=0.3)
# plot the Pref mix EBCM
t, S, I, R = EoN.EBCM_pref_mix_from_graph(G, tau, gamma, rho=rho, tmax=tmax)
plt.plot(t, I, label='Pref mix EBCM', linewidth=5, dashes=[4, 2, 1, 2, 1, 2])
plt.xlabel('$t$')
plt.ylabel('Number infected')
plt.legend()
# Now compare with ODE predictions.
#
# - Read in the degree distribution of G
# - use rho to initialize the various model equations.
# - There are versions of these functions that allow you to specify the initial conditions rather than starting from a graph.
