Add output for long calculation

navipy/moving/agent.py

@@ -29,6 +29,7 @@ from multiprocessing import Queue, JoinableQueue, Process
 import inspect
 import navipy.moving.maths as navimomath
 from navipy.database import DataBaseLoad
+import time
 
 version = float(nx.__version__)
 
@@ -379,7 +380,9 @@ the agent motion, or
 
     def compute_velocities(self,
                            ncpu=5,
-                           timeout=1):
+                           timeout=1,
+                           filename=None,
+                           blocksize=100):
         # Create a dataframe to store the velocities
         convention = self._brain.renderer.rotation_convention
         tuples_posvel = posorient_columns(convention)
@@ -415,14 +418,30 @@ the agent motion, or
 
         # Wait for all of the tasks to finish
         # posorients_queue.join()
-        for _ in range(nx.number_of_nodes(self._graph)):
+        nline = 0
+        prev_nline = nline
+        t_start = time.time()
+        nbnodes = nx.number_of_nodes(self._graph)
+        for _ in range(nbnodes):
             res = results_queue.get(timeout=timeout)
             self.velocities.loc[res.name, res.index] = res
+            if (nline-prev_nline) > blocksize:
+                t_elapse = time.time()-t_start
+                t_peritem = t_elapse/nline
+                remain = nbnodes-nline
+                print('Computed {} in {}'.format(nline, t_elapse))
+                print('Remain {}, done in {}'.format(remain, remain*t_peritem))
+                if filename is not None:
+                    self.velocities.to_hdf(filename, key='velocities')
+
+            nline += 1
         return self.velocities.copy()
 
     def build_graph(self,
                     ncpu=5,
-                    timeout=1):
+                    timeout=1,
+                    filename=None,
+                    blocksize=100):
         # Build a list of nodes
         results_edges = []
         posorients_queue = JoinableQueue()
@@ -450,11 +469,23 @@ the agent motion, or
 
         # Wait for all of the tasks to finish
         # posorients_queue.join()
-
+        nline = 0
+        prev_nline = nline
+        t_start = time.time()
+        nbnodes = nx.number_of_nodes(self._graph)
         for _ in range(nx.number_of_nodes(self._graph)):
             result = results_queue.get(timeout=timeout)
             results_edges.append((result[0].name,
                                   result[1].name))
+            if (nline-prev_nline) > blocksize:
+                t_elapse = time.time()-t_start
+                t_peritem = t_elapse/nline
+                remain = nbnodes-nline
+                print('Computed {} in {}'.format(nline, t_elapse))
+                print('Remain {}, done in {}'.format(remain, remain*t_peritem))
+                if filename is not None:
+                    np.save(filename, np.array(results_edges))
+            nline += 1
             # print(results_edges[-1])
         self._graph.add_edges_from(results_edges)
         self.check_graph()
@@ -510,10 +541,10 @@ the agent motion, or
             # [0] because one node of the attractor is enough
             # all other node of the attractor are connected to this one
             target = list(att['attractor'])[0]
-            attractors[att_i]['paths'] = \
-                nx.shortest_path(self.graph, target=target)
-            attractors[att_i]['sources'] = \
-                list(attractors[att_i]['paths'].keys())
+            attractors[att_i]['paths'] = nx.shortest_path(
+                self.graph, target=target)
+            attractors[att_i]['sources'] = list(
+                attractors[att_i]['paths'].keys())
         return attractors
 
     def catchment_area(self, attractors=None):