def load_json_taco(fp): """ Loads a temporal network from a .taco-file (which is actually in json format). Parameters ---------- fp : file-like or :obj:`str` read from this file Returns ------- temporal network type as given in the .taco-file """ file_is_string = isinstance(fp, str) if file_is_string: fp = os.path.abspath(os.path.expanduser(fp)) with open(fp, 'r') as f: this_data = json.load(f) else: this_data = json.load(fp) if this_data['type'] == 'edge_changes': temporal_network = tc.edge_changes() temporal_network.t = this_data['t'] temporal_network.t0 = this_data['t0'] temporal_network.tmax = this_data['tmax'] temporal_network.N = this_data['N'] temporal_network.edges_initial = this_data['edges_initial'] temporal_network.edges_in = this_data['edges_in'] temporal_network.edges_out = this_data['edges_out'] temporal_network.int_to_node = { int(i): s for i, s in this_data['int_to_node'].items() } temporal_network.notes = this_data['notes'] temporal_network.time_unit = this_data['time_unit'] elif this_data['type'] == 'edge_lists': temporal_network = tc.edge_lists() temporal_network.t = this_data['t'] temporal_network.tmax = this_data['tmax'] temporal_network.N = this_data['N'] temporal_network.edges = this_data['edges'] temporal_network.int_to_node = { int(i): s for i, s in this_data['int_to_node'].items() } temporal_network.notes = this_data['notes'] temporal_network.time_unit = this_data['time_unit'] else: raise ValueError( 'file is corrupted, unknown temporal network format: ' + this_data['type']) return temporal_network
(1,2), (0,2) ], [ (0,1) ], ] result = tc.measure_group_sizes_and_durations_for_edge_lists(L) print "N_m =", result.aggregated_size_histogram print "sum(m*N_m) =", np.dot(np.arange(0,L.N+1),result.aggregated_size_histogram), "should be N =", L.N print "===== edge_changes => edge_lists =====" C = tc.edge_changes() C.N = 3 C.edges_initial = [ (0,1) ] C.t0 = 0.0 C.tmax = 3.0 C.t = [ 1.0, 2.0 ] C.edges_in = [ [ (1,2), (0,2) ], [ (0,1), ], ] C.edges_out = [
import tacoma as tc from tacoma.interactive import visualize # define temporal network as a list of edge changes temporal_network = tc.edge_changes() temporal_network.N = 10 temporal_network.edges_initial = [ (0,1), (2,3), (1,7), (3,5), (1,9), (7,2) ] temporal_network.t0 = 0.0 temporal_network.t = [ 0.8, 2.4 ] temporal_network.tmax = 3.1 temporal_network.edges_in = [ [ (0, 5), (3, 6) ], [ (3, 7), (4, 9), (7, 8) ], ] temporal_network.edges_out = [ [ (0, 1) ], [ (2, 3), (3, 6) ], ] visualize(temporal_network, frame_dt = 0.05)
from __future__ import print_function import tacoma as tc dyn_RGG = tc.dynamic_RGG(N=3, t_run_total=10, mean_link_duration=2.0) test_list = tc.edge_lists(dyn_RGG) #test_list.copy_from(dyn_RGG) print(test_list.t, dyn_RGG.t) print(test_list.tmax, dyn_RGG.tmax) print(test_list.edges) print(dyn_RGG.edges) print(test_list.N, dyn_RGG.N) zsbb = tc.ZSBB_model([], 3, 0.6, 0.6, 0.6, t_run_total=100) test_list = tc.edge_changes(zsbb) print(test_list.t, zsbb.t) print(test_list.t0, zsbb.t0) print(test_list.tmax, zsbb.tmax) print(test_list.edges_in) print(zsbb.edges_in) print(test_list.edges_out) print(zsbb.edges_out) print(test_list.N, zsbb.N)
plot_size = False print "simulating" result = tc.ZSBB_model([], N, lambda_, b0, b1, t_sim, t_equilibration=t_eq, seed=1346, record_sizes_and_durations=True) print "done" this = tc.edge_changes() this.t = result.t this.N = result.N this.edges_initial = result.edges_initial this.t0 = result.t0 this.tmax = result.tmax this.edges_in = result.edges_in this.edges_out = result.edges_out print len(this.t), len(this.edges_in) print "first time point: ", this.t[0] second_result = tc.measure_group_sizes_and_durations_for_edge_changes( this, #verbose=True, )
def naive_varying_rate_edge_activity_simulation(N, t, network_densities, activity_rates, tmax): r""" Do a naive simulation of edge activity model systems where the network density and edge activity rates vary over time as step functions. It is called `naive` because the rate change will not be considered when evaluating the inter-event time at time points when the rates change. I.e. at a rate change at time `t`, the new model will be initiated as if the last event happened at time `t`. Parameters ---------- N : int number of nodes t : numpy.ndarray of float time points at which :math:`\alpha` and :math`\beta` change network_densities : numpy.ndarray of float values of :math:`\rho` for the corresponding time values in ``t``. activity_rates : numpy.ndarray of float values of :math:`\omega` for the corresponding time values in ``t``. tmax : float time at which the simulation is supposed to end. Returns ------- edge_changes : :class:`_tacoma.edge_changes` The simulated edge activity model instance. """ if len(t) != len(network_densities) or len(activity_rates) != len( network_densities): raise ValueError( 'The arrays `t`, `activity_rates` and `network_densities` must have the same length.' ) assert (t[-1] < tmax) t = np.append(t, tmax) all_networks = [] it = 0 initial_edges = [] result = None for r_, w_ in zip(network_densities, activity_rates): dt = t[it + 1] - t[it] if r_ == 1.0: r_ = (0.5 * (N - 1) * N - 1) / (0.5 * (N - 1) * N) elif r_ == 0.0: r_ = 1e-100 #print("rho =", r_, "omega =", w_) if w_ > 0.0: EAM = tc.EdgeActivityModel(N, r_, w_, save_temporal_network=True) if it > 0: EAM.set_initial_edgelist(0.0, initial_edges) tc.simulate_EdgeActivityModel(EAM, dt, reset_simulation_objects=False) this_result = EAM.edge_changes if it < len(activity_rates) - 1: initial_edges = EAM.get_current_edgelist() else: this_result = tc.edge_changes() this_result.edges_initial = initial_edges this_result.N = N this_result.t0 = 0.0 this_result.tmax = dt all_networks.append(this_result) it += 1 result = tc.concatenate(all_networks) return result