Move adaptivity_cpu_time from export output to metrics logging output

micro_manager/adaptivity/global_adaptivity.py

@@ -179,25 +179,28 @@ def get_full_field_micro_output(self, micro_output: list) -> list:
 
         return micro_sims_output
 
-    def log_metrics(self, n: int) -> None:
+    def log_metrics(self, n: int, adaptivity_cpu_time) -> None:
         """
         Log metrics for global adaptivity.
 
         Parameters
         ----------
         n : int
             Time step count at which the metrics are logged
+        adaptivity_cpu_time : float
+            CPU time taken for adaptivity calculation
         """
         global_active_sims = np.count_nonzero(self._is_sim_active)
         global_inactive_sims = np.count_nonzero(self._is_sim_active == False)
 
         self._metrics_logger.log_info_one_rank(
-            "{},{},{},{},{}".format(
+            "{},{},{},{},{},{}".format(
                 n,
                 np.mean(global_active_sims),
                 np.mean(global_inactive_sims),
                 np.max(global_active_sims),
                 np.max(global_inactive_sims),
+                adaptivity_cpu_time,
             )
         )
 

micro_manager/micro_manager.py

@@ -116,7 +116,6 @@ def __init__(self, config_file: str) -> None:
             self._adaptivity_in_every_implicit_step = (
                 self._config.is_adaptivity_required_in_every_implicit_iteration()
             )
-            self._micro_sims_active_steps = None
 
         self._adaptivity_output_n = self._config.get_adaptivity_output_n()
         self._output_adaptivity_cpu_time = self._config.output_adaptivity_cpu_time()
@@ -204,8 +203,6 @@ def solve(self) -> None:
 
             if self._output_adaptivity_cpu_time:
                 adaptivity_cpu_time += adaptivity_time
-                for i in range(self._local_number_of_sims):
-                    micro_sims_output[i]["adaptivity_cpu_time"] = adaptivity_cpu_time
 
             # Check if more than a certain percentage of the micro simulations have crashed and terminate if threshold is exceeded
             if self._interpolate_crashed_sims:
@@ -263,7 +260,7 @@ def solve(self) -> None:
                     and n % self._adaptivity_output_n == 0
                     and self._rank == 0
                 ):
-                    self._adaptivity_controller.log_metrics(n)
+                    self._adaptivity_controller.log_metrics(n, adaptivity_cpu_time)
 
                 self._logger.log_info_one_rank("Time window {} converged.".format(n))
 
@@ -704,26 +701,7 @@ def _solve_micro_simulations_with_adaptivity(
         tuple
             A tuple of micro_sims_output (list of Dicts) and adaptivity computation CPU time.
         """
-        adaptivity_cpu_time = 0.0
-
-        if self._adaptivity_in_every_implicit_step:
-            start_time = time.process_time()
-            self._adaptivity_controller.compute_adaptivity(
-                dt,
-                self._micro_sims,
-                self._data_for_adaptivity,
-            )
-            end_time = time.process_time()
-
-            adaptivity_cpu_time = end_time - start_time
-
-            active_sim_ids = self._adaptivity_controller.get_active_sim_ids()
-
-            for active_id in active_sim_ids:
-                self._micro_sims_active_steps[active_id] += 1
-
         active_sim_ids = self._adaptivity_controller.get_active_sim_ids()
-        inactive_sim_ids = self._adaptivity_controller.get_inactive_sim_ids()
 
         micro_sims_output = [0] * self._local_number_of_sims
 
@@ -798,7 +776,9 @@ def _solve_micro_simulations_with_adaptivity(
         )
         end_time = time.process_time()
 
-        adaptivity_cpu_time += end_time - start_time
+        adaptivity_cpu_time = end_time - start_time
+
+        inactive_sim_ids = self._adaptivity_controller.get_inactive_sim_ids()
 
         # Resolve micro sim output data for inactive simulations
         for inactive_id in inactive_sim_ids: