Example #1
0
 def __init__(self):
     '''
     Constructor
     '''
     self.rnd = Random()
     self.rnd_uniform = uniform()
     self.net = Network()
 def __init__(self):
     '''
     Constructor
     '''
     self.rnd = Random()
     self.rnd_uniform = uniform()
     self.net = Network()
    if (os.path.isfile('./output/'+SRC_NET_FILE)):
        shutil.copy('./output/'+SRC_NET_FILE, output_dir)
    ##############################################
    # we now make sure that links between TL 0 and 3 are removed for any network, both those read from file and those created on the fly.  
    

    network_file = output_dir+'/'+SRC_NET_FILE  ## use this when generating niche modle networks and want to save in output directory
    
    #network_file = SRC_NET_FILE  ## use this when running with networks saved locally in src
    #network_file = output_dir + '/new_network_%d.graphml' %(int(task)-1)

    
    if READ_FILE_NETWORK:
        graph = nx.read_graphml(network_file)
        net = Network(graph)
    else:
        net = obtain_interactions_network()
    
    print 'connectance = ', net.connectance()
        
    tls = net.get_trophic_levels()
        
    top, top_preds = net.top_predators()
    basal, basal_sps = net.basal()
    for u,v in net.edges():
        if u in basal_sps and v in top_preds and tls[v] == 3:
            net.remove_edge(u,v)
                
    print 'new connectance = ', net.connectance()
Example #4
0
    out_eco = csv.DictWriter(file_eco, header_names)

    ###this is for python < 2.7
    #    headers_dict = dict()
    #    for n in header_names:
    #        headers_dict[n] = n
    #
    #    out_eco.writerow(headers_dict)

    ### for python >= 2.7 comment the above block and uncomment the following line
    out_eco.writeheader()

    network_file = output_dir + '/' + SRC_NET_FILE
    if READ_FILE_NETWORK:
        graph = nx.read_graphml(network_file)
        net = Network(graph)

        print 'connectance = ', net.connectance()

        tls = net.get_trophic_levels()

        top, top_preds = net.top_predators()
        basal, basal_sps = net.basal()
        for u, v in net.edges():
            if u in basal_sps and v in top_preds and tls[v] == 3:
                net.remove_edge(u, v)

        print 'new connectance = ', net.connectance()
    else:
        net = obtain_interactions_network()
        net_to_save = net.copy()
Example #5
0
class NetworkCreator():
    '''
    classdocs
    '''
    def __init__(self):
        '''
        Constructor
        '''
        self.rnd = Random()
        self.rnd_uniform = uniform()
        self.net = Network()

#        self.invaders = []

    def reset_state(self):
        self.rnd = Random()
        self.rnd_uniform = uniform()
        self.net.clear()

    def create_niche_model_network(self, S, C, prob=False):
        '''
        prob = False; whether to create the network following the probabilistic niche model
        Niche model
        
        This is an implementation of the niche model
        '''
        ns = self.rnd_uniform.rvs(size=S + POSSIBLE_INVADERS)
        bet = (1 / (2 * C)) - 1
        self.beta_dist = beta(1, bet)

        producers = int(math.floor(S * PRIMARY_PRODS))
        current_producers = 0

        herbivores = int(math.floor(S * HERBIVORY))
        current_herbivores = 0

        predators = int(math.floor(S * TOP_PREDATORS))
        current_predators = 0
        while self.net.size() == 0 or not nx.is_connected(
                self.net.to_undirected()
        ) or current_herbivores < herbivores or current_producers < producers or current_predators < predators:  #or max(self.net.get_shortest_chain_length().values()) < 3:
            self.net.clear()
            #           self.invaders = []

            basal = None
            smallest_n = None

            #here we obtain the fundamental niche values for each one of the species in the network
            # n, c, r
            for i in range(1, S + 1):
                self.net.add_node(i)
                self.net.nodes[i]['n'] = float(ns[i -
                                                  1])  #self.rnd_uniform.rvs()
                self.net.nodes[i]['r'] = self.beta_dist.rvs(
                ) * self.net.nodes[i]['n']
                self.net.nodes[i]['c'] = self.rnd.uniform(
                    (self.net.nodes[i]['r'] / 2),
                    min(self.net.nodes[i]['n'],
                        (1 - (self.net.nodes[i]['r'] / 2))))
                #the original value of c (commented bit) as originally presented in the Nature 2000 paper
                #was changed after reading the niche model specification presented in the JAE 2008 paper
                #the new specification ensures that the r of all the species always lie within the niche interval [0,1]
                #self.net.node[i]['c'] = self.rnd.uniform(self.net.node[i]['r']/2, self.net.node[i]['n'])
                self.net.nodes[i]['invader'] = False

                if smallest_n == None or self.net.nodes[i]['n'] < smallest_n:
                    smallest_n = self.net.nodes[i]['n']
                    basal = i

            #if INVASION:


#            for i in xrange(S+1, (S+1)+(POSSIBLE_INVADERS)):
##                invader = dict()
##                invader['n'] = self.rnd_uniform.rvs()
##                invader['r'] = self.beta_dist.rvs() * self.net.node[i]['n']
##                invader['c'] = self.rnd.uniform(self.net.node[i]['r']/2, self.net.node[i]['n'])
##                invader['invader'] = True
#
#                self.net.add_node(i)
#                self.net.node[i]['n'] = float(ns[i-1]) #self.rnd_uniform.rvs()
#                self.net.node[i]['r'] = self.beta_dist.rvs() * self.net.node[i]['n']
#                self.net.node[i]['c'] = self.rnd.uniform((self.net.node[i]['r']/2), min(self.net.node[i]['n'], (1-(self.net.node[i]['r']/2))))
#                self.net.node[i]['invader'] = False

#                self.invaders.append(invader)

            self.net.nodes[basal]['r'] = 0.0
            self._create_links_based_on_fundamental_niche()

            current_herbivores = 0
            current_producers = 0
            current_predators = 0
            tls = self.net.get_trophic_levels()
            for k in tls.keys():
                if tls[k] == 1:
                    current_herbivores += 1
                elif tls[k] == 0:
                    current_producers += 1
                elif tls[k] == 3:
                    current_predators += 1

        return self.net

    def _create_links_based_on_fundamental_niche(self, nodes_to_link=None):
        #based on the fundamental niche values obtained above we construct the network by adding
        #the corresponding links according to the species' niche and feeding range

        if nodes_to_link == None:
            nodes_to_link = set(self.net.nodes())

        for i in self.net.nodes():
            if self.net.nodes[i]['r'] == 0.0:
                continue

            r_lower_bound = self.net.nodes[i]['c'] - (self.net.nodes[i]['r'] /
                                                      2)
            r_upper_bound = self.net.nodes[i]['c'] + (self.net.nodes[i]['r'] /
                                                      2)
            for j in self.net.nodes():
                if i not in nodes_to_link and j not in nodes_to_link:
                    continue

                if self.net.nodes[j]['n'] >= r_lower_bound and self.net.nodes[
                        j]['n'] <= r_upper_bound:
                    self.net.add_edge(j, i)

        #for disconnected or duplicated nodes
        disc_nodes = set()
        self_loops = set(nx.selfloop_edges(self.net))

        for i in nodes_to_link:
            disconnected = False

            if self.net.degree(i) == 0:
                disconnected = True
            elif self.net.in_degree(i) == 1 and (i, i) in self_loops:
                #                print 'producer with selfloop'
                if self.net.out_degree(i) > 1:
                    self.net.remove_edge(i, i)
                else:
                    disconnected = True
                    attrs = self.net.nodes[i]
                    self.net.remove_node(i)
                    self.net.add_node(i, attr_dict=attrs)
            else:
                i_succs = set(self.net.successors(i))
                i_predecs = set(self.net.predecessors(i))
                for j in self.net.nodes():
                    j_succs = self.net.successors(j)
                    j_predecs = self.net.predecessors(j)

                    if i_succs == j_succs and i_predecs == j_predecs:
                        disconnected = True
                        attrs = self.net.nodes[i]
                        self.net.remove_node(i)
                        self.net.add_node(i, attr_dict=attrs)
                        print('duplicated node')
                        break

            #we reassign the fundamental niche values to nodes that are disconnected or duplicated
            if disconnected:
                self.net.nodes[i]['n'] = self.rnd_uniform.rvs()
                self.net.nodes[i]['r'] = self.beta_dist.rvs(
                ) * self.net.nodes[i]['n']
                self.net.nodes[i]['c'] = self.rnd.uniform(
                    self.net.nodes[i]['r'] / 2, self.net.nodes[i]['n'])
                disc_nodes.add(i)

        if len(disc_nodes) > 0:
            self._create_links_based_on_fundamental_niche(disc_nodes)

        return
class NetworkCreator():
    '''
    classdocs
    '''
    def __init__(self):
        '''
        Constructor
        '''
        self.rnd = Random()
        self.rnd_uniform = uniform()
        self.net = Network()
    
#        self.invaders = []
    
    def reset_state(self):
        self.rnd = Random()
        self.rnd_uniform = uniform()
        self.net.clear()
    
    def create_niche_model_network(self, S, C, prob=False):
        '''
        prob = False; whether to create the network following the probabilistic niche model
        Niche model
        
        This is an implementation of the niche model
        '''
        ns = self.rnd_uniform.rvs(size=S+POSSIBLE_INVADERS)
        bet = (1/(2*C)) - 1
        self.beta_dist = beta(1,bet)
        
        producers = int(math.floor(S*PRIMARY_PRODS))
        current_producers = 0
        
        herbivores = int(math.floor(S*HERBIVORY))
        current_herbivores = 0 
        
        predators = int(math.floor(S*TOP_PREDATORS))
        current_predators = 0    

	#basal_to_top_links = 1  ## New constraint that this must be zero!

        while self.net.size() == 0 or not nx.is_connected(self.net.to_undirected()) or current_producers < producers or current_herbivores < herbivores or current_predators < predators: #or max(self.net.get_shortest_chain_length().values()) < 3:
            self.net.clear()
#            self.invaders = []
            
            basal = None
            smallest_n = None
            
            #here we obtain the fundamental niche values for each one of the species in the network
            # n, c, r
            for i in xrange(1,S+1):
                self.net.add_node(i)
                self.net.node[i]['n'] = float(ns[i-1]) #self.rnd_uniform.rvs()
                self.net.node[i]['r'] = self.beta_dist.rvs() * self.net.node[i]['n']
                self.net.node[i]['c'] = self.rnd.uniform((self.net.node[i]['r']/2), min(self.net.node[i]['n'], (1-(self.net.node[i]['r']/2))))
                #the original value of c (commented bit) as originally presented in the Nature 2000 paper
                #was changed after reading the niche model specification presented in the JAE 2008 paper
                #the new specification ensures that the r of all the species always lie within the niche interval [0,1]
                #self.net.node[i]['c'] = self.rnd.uniform(self.net.node[i]['r']/2, self.net.node[i]['n'])
                self.net.node[i]['invader'] = False
                
                if smallest_n == None or self.net.node[i]['n'] < smallest_n:
                    smallest_n = self.net.node[i]['n']
                    basal = i
            
            #if INVASION:
#            for i in xrange(S+1, (S+1)+(POSSIBLE_INVADERS)):
##                invader = dict()
##                invader['n'] = self.rnd_uniform.rvs()
##                invader['r'] = self.beta_dist.rvs() * self.net.node[i]['n']
##                invader['c'] = self.rnd.uniform(self.net.node[i]['r']/2, self.net.node[i]['n'])
##                invader['invader'] = True
#                
#                self.net.add_node(i)
#                self.net.node[i]['n'] = float(ns[i-1]) #self.rnd_uniform.rvs()
#                self.net.node[i]['r'] = self.beta_dist.rvs() * self.net.node[i]['n']
#                self.net.node[i]['c'] = self.rnd.uniform((self.net.node[i]['r']/2), min(self.net.node[i]['n'], (1-(self.net.node[i]['r']/2))))
#                self.net.node[i]['invader'] = False
                
#                self.invaders.append(invader)
                          
            self.net.node[basal]['r'] = 0.0    
            self._create_links_based_on_fundamental_niche()


            tls = self.net.get_trophic_levels()
	    # replacement of links between trophic levels 0 and 3 (does not conform to niches):
            top, top_preds = self.net.top_predators()
            basal, basal_sps = self.net.basal()
	    #basal_to_top_links = 0
	    to_replace = []
            for u,v in self.net.edges():
                if u in basal_sps and v in top_preds and tls[v] == 3:
                    #basal_to_top_links += 1
		    self.net.remove_edge(u,v)
		    to_replace.append((u,v))
       
	    for pair in to_replace:
		new_u = pair[1]
		while new_u in basal_sps or new_u==pair[1]:
			new_u = np.random.randint(1,61)     # species indexing starts at 1
		self.net.add_edge(new_u, pair[1]) 
            
	    # calculations to check trophic constraints:
            current_herbivores = 0
            current_producers = 0
            current_predators = 0
            for k in tls.keys():
                if tls[k] == 1:
                    current_herbivores += 1 
                elif tls[k] == 0:
                    current_producers += 1
                elif tls[k] == 3:
                    current_predators += 1

        print("replaced %d links" %(len(to_replace)))
        return self.net
            
    def _create_links_based_on_fundamental_niche(self, nodes_to_link=None):
        #based on the fundamental niche values obtained above we construct the network by adding
        #the corresponding links according to the species' niche and feeding range
        
        if nodes_to_link == None:
            nodes_to_link = set(self.net.nodes())
        
        for i in self.net.nodes():
            if self.net.node[i]['r'] == 0.0:
                continue
            
            r_lower_bound = self.net.node[i]['c'] - (self.net.node[i]['r']/2)
            r_upper_bound = self.net.node[i]['c'] + (self.net.node[i]['r']/2) 
            for j in self.net.nodes():
                if i not in nodes_to_link and j not in nodes_to_link:
                    continue
                
                if self.net.node[j]['n'] >= r_lower_bound and self.net.node[j]['n'] <= r_upper_bound:  
                    self.net.add_edge(j,i)
        
        #for disconnected or duplicated nodes
        disc_nodes = set()        
        self_loops = set(self.net.selfloop_edges())
        
        for i in nodes_to_link:
            disconnected = False
            
            if self.net.degree(i) == 0:
                disconnected = True
            elif self.net.in_degree(i) == 1 and (i,i) in self_loops:
#                print 'producer with selfloop'
                if self.net.out_degree(i) > 1:
                    self.net.remove_edge(i,i)
                else:
                    disconnected = True
                    attrs = self.net.node[i]
                    self.net.remove_node(i)
                    self.net.add_node(i, attr_dict=attrs)
            else:
                i_succs = set(self.net.successors(i))
                i_predecs = set(self.net.predecessors(i))
                for j in self.net.nodes():
                    j_succs = self.net.successors(j)
                    j_predecs = self.net.predecessors(j)
                    
                    if i_succs == j_succs and i_predecs == j_predecs:
                        disconnected = True
                        attrs = self.net.node[i]
                        self.net.remove_node(i)
                        self.net.add_node(i, attr_dict=attrs)
                        print 'duplicated node'
                        break
                    
            #we reassign the fundamental niche values to nodes that are disconnected or duplicated        
            if disconnected:
                self.net.node[i]['n'] = self.rnd_uniform.rvs()
                self.net.node[i]['r'] = self.beta_dist.rvs() * self.net.node[i]['n']
                self.net.node[i]['c'] = self.rnd.uniform(self.net.node[i]['r']/2, self.net.node[i]['n'])
                disc_nodes.add(i)
                
        
        if len(disc_nodes) > 0:
            self._create_links_based_on_fundamental_niche(disc_nodes)
        
        return
base_dir = "/MyFiles/cm1788/Documents/prunning_for_stability/bc3_results/network_structure_vs_persistence/rewired/bad_net_59/"
#base_dir = "/MyFiles/cm1788/Documents/prunning_for_stability/bc3_results/network_structure_vs_persistence/rewired/good_net_52/"

#graphml_file = "/MyFiles/cm1788/Documents/prunning_for_stability/bc3_results/network_structure_vs_persistence/noconstraints/bad_net_54/new_network_53_wtl.graphml"
#graphml_file = "/MyFiles/cm1788/Documents/prunning_for_stability/bc3_results/network_structure_vs_persistence/noconstraints/good_net_74/new_network_73_wtl.graphml"
#graphml_file = "/MyFiles/cm1788/Documents/prunning_for_stability/bc3_results/network_structure_vs_persistence/rewired/good_net_52/rewired_network_51.graphml"
graphml_file = base_dir + "rewired_network_58.graphml"
#graphml_file = base_dir + "rewired_network_51.graphml"

all_results = np.zeros((3,7))

for rr in range(1):


	G = nx.read_graphml(graphml_file)
	Net = Network(G)
	G = nx.Graph(G)
	
	#find modularity
	#net = Network(G)
	#tls = net.get_trophic_levels()
	#part = community.best_partition(G)
	#IG = igr.read_graphml(graphml_file)
	IG = igr.load(graphml_file)
	IG.to_undirected() # = IG0.to_undirected()
	membs = IG.community_multilevel()
	mod = IG.modularity(membs)
	#mod = modularity(part, G)
	print("Modularity:")
	print(mod)
	print(IG.transitivity_undirected())