before graph firm prod

model.py

@@ -146,7 +146,27 @@ class Model(ap.Model):
                 firm.a_lst_product_removed.append(product)
 
         # draw network
-        # self.draw_network()
+        self.draw_network()
+
+        print(self.a_lst_total_firms)
+        print(self.a_lst_total_firms[133])
+        print(self.a_lst_total_firms[133].code)
+        print(self.firm_network.positions[self.a_lst_total_firms[133]])
+        print(
+            self.firm_network.graph[self.firm_network.positions[self.a_lst_total_firms[133]]])
+        iter_g = iter(
+            self.firm_network.graph[self.firm_network.positions[self.a_lst_total_firms[133]]])
+        f_t = next(iter_g)
+        print(f_t)
+        iter_g = iter(self.firm_network.graph[f_t])
+        print(next(iter_g))
+
+        print(self.a_lst_total_firms[133].get_firm_network_node())
+        print(list(self.dfs_edges_prod(self.firm_network.graph,
+              self.a_lst_total_firms[133],
+              self.a_lst_total_firms[133].a_lst_product[0])))
+        print(self.betweenness_centrality_firm_prod(self.firm_network.graph))
+        print()
 
     def update(self):
         self.a_lst_total_firms.clean_before_time_step()
@@ -312,7 +332,7 @@ class Model(ap.Model):
         node_label = nx.get_node_attributes(self.firm_network.graph, 'Name')
         node_degree = dict(self.firm_network.graph.out_degree())
         node_label = {
-            key: f"{node_label[key]} {node_degree[key]}"
+            key: f"{key} {node_label[key]} {node_degree[key]}"
             for key in node_label.keys()
         }
         node_size = list(
@@ -334,3 +354,83 @@ class Model(ap.Model):
                                      edge_label,
                                      font_size=4)
         plt.savefig("network.png")
+
+    @ staticmethod
+    def dfs_edges_prod(G, start_firm, start_prod, depth_limit=None):
+        assert start_prod in start_firm.a_lst_product, \
+            f"product {start_prod.code} not in firm {start_firm.code}"
+
+        visited = set()
+        if depth_limit is None:
+            depth_limit = len(G)
+
+        start_node = start_firm.get_firm_network_node()
+        visited.add(start_firm)
+        stack = [(start_firm, start_prod, depth_limit, iter(G[start_node]))]
+        while stack:
+            parent_firm, parent_prod, depth_now, children_node = stack[-1]
+            try:
+                child_node = next(children_node)
+                child_firm = \
+                    ap.AgentIter(start_firm.model, child_node).to_list()[0]
+                if child_firm not in visited:
+                    for child_prod in child_firm.a_lst_product:
+                        if child_prod not in parent_prod.a_successors():
+                            continue
+                        yield parent_firm.code, parent_prod.code, child_firm.code, child_prod.code
+                        visited.add(child_firm)
+                        if depth_now > 1:
+                            stack.append((child_firm,
+                                          child_prod,
+                                          depth_now - 1,
+                                          iter(G[child_node])))
+            except StopIteration:
+                stack.pop()
+
+    @ staticmethod
+    def betweenness_centrality_firm_prod(G):
+        def _single_source_shortest_path_basic(G, s):
+            S = []
+            P = {}
+            for v in G:
+                P[v] = []
+            sigma = dict.fromkeys(G, 0.0)  # sigma[v]=0 for v in G
+            D = {}
+            sigma[s] = 1.0
+            D[s] = 0
+            Q = [s]
+            while Q:  # use BFS to find shortest paths
+                v = Q.pop(0)
+                S.append(v)
+                Dv = D[v]
+                sigmav = sigma[v]
+                for w in G[v]:
+                    if w not in D:
+                        Q.append(w)
+                        D[w] = Dv + 1
+                    if D[w] == Dv + 1:  # this is a shortest path, count paths
+                        sigma[w] += sigmav
+                        P[w].append(v)  # predecessors
+            return S, P, sigma
+
+        def _accumulate_basic(betweenness, S, P, sigma, s):
+            delta = dict.fromkeys(S, 0)
+            while S:
+                w = S.pop()
+                coeff = (1 + delta[w]) / sigma[w]
+                for v in P[w]:
+                    delta[v] += sigma[v] * coeff
+                if w != s:
+                    betweenness[w] += delta[w]
+            return betweenness
+
+        betweenness = dict.fromkeys(G, 0.0)  # b[v]=0 for v in G
+        nodes = G
+        for s in nodes:
+            # single source shortest paths
+            # use BFS for unweighted g
+            S, P, sigma = _single_source_shortest_path_basic(G, s)
+            # accumulation without endpoint
+            betweenness = _accumulate_basic(betweenness, S, P, sigma, s)
+
+        return betweenness