def main(): print "updating_rule module is the main code." edge_file = '../data/inputs/edges-init.dat' ############################# ## Read in anterior nodes ############################# node_file = '../data/inputs/ant-nodes-init.dat' desired_node_file = '../data/inputs/ant-nodes-final.dat' G = inet.read_network_from_file(edge_file, node_file) nodes_list = G.nodes() node_dict = nx.get_node_attributes(G,'state') init_dID = time_evol.binary_to_decimal(nodes_list, node_dict) ############################# ## Read in posterior nodes ############################# post_node_file = '../data/inputs/post-nodes-init.dat' post_desired_node_file = '../data/inputs/post-nodes-final.dat' G_post = inet.read_network_from_file(edge_file, post_node_file) post_nodes_list = G_post.nodes() post_node_dict = nx.get_node_attributes(G_post,'state') post_init_dID = time_evol.binary_to_decimal(post_nodes_list, post_node_dict) ############################# # print G.nodes() # print G.edges() # prev_state = nx.get_node_attributes(G,'state') # dict of key=node, value=state of network G # print "network state @ prev step", OrderedDict(sorted(prev_state.items(), key=lambda t: t[0])) # curr_state = boolean_updating(G) # print "network state @ curr step", OrderedDict(sorted(curr_state.items(), key=lambda t: t[0])) # print prev_state # print curr_state ###### calc steady state probabilities ##################################################### # init_dID,desired_dID = 0, 43 init_dID,desired_dID = 20, 980 attractor_dict, prob_desired_dID = full_steady_state_calc(G,nodes_list,init_dID,desired_dID) print attractor_dict print prob_desired_dID exit() ############################################################################################# ## Create deterministic transition graph state_trans_dict = create_state_transitions_dict(G) G_state_trans = create_graph_from_transitions(state_trans_dict) # stochastic transition graph ## Calculate in and out degrees of transition graph out_deg_dict = G_state_trans.out_degree(G_state_trans.nodes()) sorted_out_deg_dict = sorted(out_deg_dict.items(), key=operator.itemgetter(1)) in_deg_dict = G_state_trans.in_degree(G_state_trans.nodes()) sorted_in_deg_dict = sorted(in_deg_dict.items(), key=operator.itemgetter(1)) largest = max(nx.strongly_connected_components(G_state_trans), key=len) # print len(largest) # this shows that graph of stochastic state transitions is strongly connected # attractors = time_evol.find_attractor_old(G_state_trans) create_transition_matrix(state_trans_dict) deterministic_transition_graph = time_evol.net_state_transition(G, nodes_list) # deterministic transition graph attractors = time_evol.find_attractor_old(deterministic_transition_graph) # this must only print out cycles for a subset of the graph... ############################# ## Find control kernals ############################# attractor_ID = 980 # print find_len_1_control_kernals(deterministic_transition_graph, nodes_list, attractor_ID) # print find_len_2_control_kernals(deterministic_transition_graph, nodes_list, attractor_ID) print find_len_2_control_kernals_fo_real(deterministic_transition_graph, nodes_list, attractor_ID) exit() ############################# ## Desired node states ## Anterior G_desired = inet.read_network_from_file(edge_file, desired_node_file) desired_nodes_list = G_desired.nodes() desired_node_dict = nx.get_node_attributes(G_desired,'state') desired_dID = time_evol.binary_to_decimal(desired_nodes_list,desired_node_dict) print "desired_node_dict:", desired_node_dict print "desired dID:", desired_dID ## Posterior G_desired_post = inet.read_network_from_file(edge_file, post_desired_node_file) post_desired_nodes_list = G_desired_post.nodes() post_desired_node_dict = nx.get_node_attributes(G_desired_post,'state') post_desired_dID = time_evol.binary_to_decimal(post_desired_nodes_list,post_desired_node_dict) print "post_desired_node_dict:", post_desired_node_dict print "desired dID:", post_desired_dID ## Check if path between desired init state and final state print nx.has_path(deterministic_transition_graph,init_dID,desired_dID) ## Print binary version of attractors print "attractors:" print attractors ## Network 980 is the steady state network, let's see if this is correct based on rules # steady_state_network = print "end_ant:", desired_node_dict print "beg_ant:", node_dict print "end_ant_dID:", desired_dID print "beg_ant_dID:", init_dID print "end_post:", post_desired_node_dict print "beg_post:", post_node_dict print "end_post_dID:", post_desired_dID print "beg_post_dID:", post_init_dID # print attractors # print G_state_trans.edges() # for line in nx.generate_edgelist(G_state_trans, data=False): # print line # nx.draw(G_state_trans) # nx.write_graphml(G_state_trans,'g_state_trans.xml') # plt.show() # for graph in list(nx.weakly_connected_component_subgraphs(deterministic_transition_graph)): # if 43 in graph.nodes(): # print [time_evol.decimal_to_binary(nodes_list, dID) for dID in graph.nodes()] # print " 0:", time_evol.decimal_to_binary(nodes_list, 0) # print "683:", time_evol.decimal_to_binary(nodes_list, 683) # nx.draw(deterministic_transition_graph) # nx.write_graphml(deterministic_transition_graph,'deterministic_transition_graph.xml') # plt.show() exit()
def create_state_transitions_dict(G): """ output a dictionary of key=network_ID, value=list of possible next network_IDs each of the next possible network_IDs is exactly 1 value different than the previous network ID this is working correctly- trust past harrison 4/13/16 """ state_trans_dict = {} # key=network_ID, value=list of next network IDs n_nodes = len(G.nodes()) n_init_networks = time_evol.n_states**n_nodes for prev_network_ID in range(0, n_init_networks): nodes_list = G.nodes() prev_network_bID = time_evol.decimal_to_binary(nodes_list, prev_network_ID) #same as 'prev_state' within boolean_updating curr_network_bID = boolean_updating(G, prev_state=prev_network_bID) # get list of nodes that change when applying update rule altered_nodes = [] for node in curr_network_bID: if prev_network_bID[node] != curr_network_bID[node]: altered_nodes.append(node) # print prev_network_ID, altered_nodes # look through altered nodes, and make list of all networks with nodes being altered 1 at a time state_trans_dict[prev_network_ID] = [] for node in altered_nodes: possible_bID = copy.deepcopy(prev_network_bID) # print possible_bID #why is this not changing??? not_flipped = True # print possible_bID[node] # if node was updated, flip it if prev_network_bID[node] == 0: possible_bID[node] = 1 not_flipped = False # print "0, flipping" # print possible_bID[node] # if node was updated, flip it elif (prev_network_bID[node] == 1) and (not_flipped == True): possible_bID[node] = 0 # print "1, flipping" # print possible_bID[node] else: raise ValueError("Node %s of prev_state must be 0 or 1. Something bad happened."%node) # print possible_bID # nodes_list = [k for k in possible_bID] network_ID = time_evol.binary_to_decimal(nodes_list,possible_bID) #get network_ID of this possible next state state_trans_dict[prev_network_ID].append(network_ID) # if no nodes are altered, you're in a fixed stable state-- make state_trans_dict[stable_ID]=stable_ID if len(altered_nodes) == 0: state_trans_dict[prev_network_ID].append(prev_network_ID) # print 'prev network ID:',prev_network_ID return state_trans_dict