Finish base community implementation

pydtn/community.py

@@ -20,8 +20,8 @@ __version__ = '0.1'
 __author__ = 'Jarrod Pas <j.pas@usask.ca>'
 
 from collections import defaultdict
+from itertools import product
 
-# TODO: Consider using igraph instead of networkx - jpas (2017-08-11)
 import networkx as nx
 from community import best_partition as louvain_partition
 
@@ -43,8 +43,8 @@ class Community:
         self.epoch = epoch
 
         self.graph = nx.Graph()
+        self.graph_old = None
 
-        self._prev_graph = None
         self._community = {}
 
     def start(self, network):
@@ -64,54 +64,62 @@ class Community:
         env = self.network.env
         while True:
             yield env.timeout(self.epoch)
-            new_graph = nx.Graph()
+            print('epoch')
 
+            new = nx.Graph()
             for node_a, node_b, start in self.graph.edges(data='start'):
                 if start is not None:
                     self.leave(node_a, node_b)
-                    data = {
-                        'start': env.now,
-                        'duration': 0,
-                    }
-                    new_graph.add_edge(node_a, node_b, data)
+                    self.join(node_a, node_b, graph=new)
 
-            self.graph, self._prev_graph = new_graph, self.graph
-            self.partition()
+            self.graph_old = self.graph
+            self.graph = new
+
+            for community in self.partition():
+                for node in community:
+                    self._community[node] = community
 
     def partition(self):
         """Partition nodes into communities."""
-        self._community = {}
-
-        for node in self._prev_graph.nodes():
-            self._community[node] = frozenset(list(node))
+        for node in self.graph_old.node():
+            yield frozenset([node])
 
-    def join(self, node_a, node_b):
+    def join(self, node_a, node_b, graph=None):
         """
         Node a and b join each other's neighbourhoods.
 
         This is an idempotent operation.
         """
-        if not self.graph.has_edge(node_a, node_b):
-            data = {
+        if graph is None:
+            if self.graph is None:
+                return
+            graph = self.graph
+
+        if not graph.has_edge(node_a, node_b):
+            graph.add_edge(node_a, node_b, {
                 'start': None,
-                'duration': 0,
-            }
-            self.graph.add_edge(node_a, node_b, data)
+                'weight': 0,
+            })
 
-        edge = self.graph[node_a][node_b]
+        edge = graph[node_a][node_b]
         if edge['start'] is None:
             edge['start'] = self.network.env.now
 
-    def leave(self, node_a, node_b):
+    def leave(self, node_a, node_b, graph=None):
         """
         Node a and b leave each other's neighbourhoods.
 
         This is an idempotent operation.
         """
-        if self.graph.has_edge(node_a, node_b):
-            edge = self.graph[node_a][node_b]
+        if graph is None:
+            if self.graph is None:
+                return
+            graph = self.graph
+
+        if graph.has_edge(node_a, node_b):
+            edge = graph[node_a][node_b]
             if edge['start'] is not None:
-                edge['duration'] += self.network.env.now - edge['start']
+                edge['weight'] += self.network.env.now - edge['start']
                 edge['start'] = None
 
     def __getitem__(self, node):
@@ -126,7 +134,7 @@ class Community:
 
     def local_popularity(self, node):
         """Return local popularity of a node."""
-        graph = self._prev_graph
+        graph = self.graph_old
         if node not in graph:
             return 0
 
@@ -138,7 +146,7 @@ class Community:
 
     def global_popularity(self, node):
         """Return global popularity of a node."""
-        graph = self._prev_graph
+        graph = self.graph_old
         if node not in graph:
             return 0
 
@@ -149,10 +157,15 @@ class Community:
         )
 
     def unique_interactions(self, node):
-        graph = self._prev_graph
+        """Unique interactions for a node within it's community."""
+        graph = self.graph_old
         if node not in graph:
             return 0
-        return len(graph[node])
+        return len(
+            other
+            for other in node.community
+            if other in graph[node]
+        )
 
     def community_betweenness(self, node_a, node_b):
         """Return community betweenness for 2 nodes."""
@@ -162,7 +175,7 @@ class Community:
         if community_a == community_b:
             return float('inf')
 
-        graph = self._prev_graph
+        graph = self.graph_old
         return sum(
             graph[node_a][node_b]['duration']
             for node_a, node_b in product(community_a, community_b)
@@ -170,30 +183,17 @@ class Community:
         )
 
 
-
 class KCliqueCommunity(Community):
     """K-clique community detection."""
 
-    def __init__(self, epoch, k, threshold):
+    def __init__(self, epoch, k):
         """Create a k-clique community detector."""
         super().__init__(epoch)
-
         self.k = k
-        self.threshold = threshold
 
     def partition(self):
-        """Partition graph by k-clique."""
-        graph = nx.Graph()
-
-        for edge in self._prev_graph.edges(data='duration'):
-            duration = edge[2]
-            if duration > self.threshold:
-                graph.add_edge(*edge)
-
-        communities = nx.k_clique_communities(graph, self.k)
-        for community in communities:
-            for node in community:
-                self._community[node] = community
+        """Partition graph by k-clique communities method."""
+        return nx.k_clique_communities(self.graph_old, k=self.k)
 
 
 class LouvainCommunity(Community):
@@ -201,16 +201,14 @@ class LouvainCommunity(Community):
 
     def partition(self):
         """Partition graph with Louvain algorithm."""
-        partitions = louvain_partition(self._prev_graph, weight='duration')
+        partitions = louvain_partition(self.graph_old)
+
         communities = defaultdict(set)
         for node, community in partitions.items():
             communities[community].add(node)
 
         for community in communities.values():
-            community = frozenset(community)
-            for node in community:
-                self._community[node] = community
-
+            yield frozenset(community)
 
 class CommunityNode(Node):
     """Base node for community based forwarding heuristics."""
@@ -227,6 +225,24 @@ class CommunityNode(Node):
         super().start(network)
         self._community.start(network)
 
+    def join(self, node):
+        """
+        Approach the neighbouhood of this node.
+
+        This is an idempotent operation.
+        """
+        super().join(node)
+        self._community.join(self, node)
+
+    def leave(self, node):
+        """
+        Leave the neighbouhood of this node.
+
+        This is an idempotent operation.
+        """
+        super().leave(node)
+        self._community.leave(self, node)
+
     @property
     def community(self):
         """Return my community."""
@@ -261,11 +277,6 @@ class BubbleNode(CommunityNode):
         if forward:
             return forward
 
-        if self.in_community_neighbours:
-            return {}
-        elif self.out_community_neighbour:
-            return {}
-
         return {}