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))