def make_optimal_network(deep_load=False, load_black=True):
_, routes = load_airport_and_route(deep_load=deep_load)
netx = from_edgelist(routes)
N = number_of_nodes(netx)
net = network(N, graph=netx)
optimal = optimal_distribution(deep_load=deep_load)
R = B = [balls_per_node] * N
if load_black:
B = optimal
else:
R = optimal
net.set_initial_distribution(R, B)
from execute.import_data import load_airport_and_route
from utilities import filter_degree, re_index, balls_per_node
from networkx import diameter, from_edgelist
# Import data
nodes, edges = load_airport_and_route(deep_load=True, filter_data=False)
# Print information about network
print('Raw data')
print('Num nodes: ' + str(len(nodes)))
print('Num edges: ' + str(len(edges)))
# Filter network
nodes, _, edges = filter_degree(nodes, edges)
nodes, edges = re_index(nodes, edges)
netx = from_edgelist(edges)
# Print information about filtered network
print('Filtered data')
print('Num nodes: ' + str(len(nodes)))
print('Num edges: ' + str(len(edges)))
print('Budget: ' + str(len(nodes) * balls_per_node) + ', with ' +
str(balls_per_node) + ' per node')
print('Diameter: ' + str(diameter(netx)))
from execute.import_data import load_airport_and_route
from networkx import from_edgelist, number_of_nodes, degree
from model import network, optimize_distribution
from utilities import save_distribution, balls_per_node
from time import time
from numpy import array
# Import and filter data
uniform = False
nodes, edges = load_airport_and_route()
# Generate network
netx = from_edgelist(edges)
N = number_of_nodes(netx)
net = network(N, graph=netx)
# Generate structures for optimization
neighbourhoods = [[neigh.id for neigh in node] for node in net.nodes]
R, B = [balls_per_node] * N, [balls_per_node] * N
budget = balls_per_node * N
if not uniform:
degrees = degree(netx)
degrees = array(sorted(degrees, key=lambda d: d[1], reverse=True))
R = [0] * N
R[degrees[0, 0]] = N * balls_per_node
# Optimize
start = time()
distribution, exp = optimize_distribution(neighbourhoods, R, B, budget)
end = time()
from model import network
from utilities import balls_per_node, dict_to_arr, save_trials
from networkx import from_edgelist, degree
from numpy import argmax, zeros, array
from execute.run_polya import run_polya
from utilities.plotting import plot_infection
from execute.import_data import load_airport_and_route
from model.optimize import simple_centrality, metric_names
from execute.optimal_distribution import optimal_distribution
# Red distribution (uniform or single)
uniform = False
airports, routes = load_airport_and_route(deep_load=True) # Import data
N = len(airports) # Initialize N
budget = balls_per_node * N
netx = from_edgelist(routes) # Generate networkx network
net = network(N, graph=netx) # Generate network
print('Data imported and network generated')
degrees = array(sorted(degree(netx), key=lambda d: d[0]))[:, 1]
max_d_node = argmax(degrees) # Get index of max degree
optimal = optimal_distribution(deep_load=True)
if uniform:
red = array([balls_per_node] * N)
else:
red = zeros(N)
red[max_d_node] = budget
exposures = []
from model import network
from utilities import balls_per_node, save_trials
from networkx import from_edgelist, degree, number_of_nodes
from numpy import argmax, zeros, array
from execute.run_polya import run_polya
from execute.import_data import load_airport_and_route
from execute.optimal_distribution import optimal_distribution
# Choose simulation options
uniform = False
num_steps = 250
# Load data and generate network
_, routes = load_airport_and_route(deep_load=True)
netx = from_edgelist(routes)
N = number_of_nodes(netx)
net = network(N, graph=netx)
budget = balls_per_node * N
print('Data imported and network generated')
# Get optimal distribution
optimal = optimal_distribution(uniform, deep_load=True)
# Initialize opponent distribution
if uniform:
red = array([balls_per_node] * N)
else:
degrees = array(sorted(degree(netx), key=lambda d: d[0]))[:, 1]
max_d_node = argmax(degrees)
red = zeros(N)
red[max_d_node] = budget
from execute.import_data import load_airport_and_route
from networkx import from_edgelist, betweenness_centrality, number_of_nodes
from utilities import dict_to_arr, re_index, balls_per_node
from numpy import array
from utilities.plotting import plot_network
# Define constants
cut_off = 11
fig_path = '../../results/network/slim.png'
# Import data and generate network
nodes, edges = load_airport_and_route(deep_load=True)
netx = from_edgelist(edges)
# Calculate betweenness
cents = dict_to_arr(betweenness_centrality(netx), conv=False)
cents = array(sorted(cents, key=lambda c: c[1], reverse=True))
# Pull nodes
slim_set = []
for i in range(cut_off):
ind = int(round(cents[i, 0]))
slim_set.append(nodes[ind])
slim_set = array(slim_set)
# Filter old edges
n_nodes, n_edges = re_index(slim_set, edges)
n_netx = from_edgelist(n_edges)
# Generate ball distribution
N = number_of_nodes(netx)
from execute.import_data import load_airport_and_route
from execute.optimal_distribution import optimal_distribution
from utilities.plotting import plot_net_w_routes, plot_network
from networkx import from_edgelist
from utilities import filter_degree, re_index
from numpy import max, min, multiply, add
# Define constants
data_path = '../../data/optimal_distribution/f_100_analytical.csv'
path = '../../results/network/optimal.csv'
# Import data and filter
airports, routes = load_airport_and_route(deep_load=True, filter_data=False)
airports, _, routes = filter_degree(airports, routes, d_cut_off=100)
airports, routes = re_index(airports, routes)
# Initialize/calculate plotting values
weights = optimal_distribution(alt_file=data_path)
min_val, max_val = min(weights), max(weights)
delt = max_val - min_val
weights = multiply(add(weights, -min_val), 1 / delt)
# Plot network
netx = from_edgelist(routes)
plot_network(netx,
netx_plot=True,
weights=weights,
file_name=path,
plot_edges=True,
size=(10, 6))
