Fix bug in adaptivity computation when an active simulation with associations is deactivated (#171)

* Fix bug when adaptivity is computed in every implicit iteration

* Calculate association after deactivating simulations

* Only delete simulation objects AFTER the inactive update is completed

* Add changelog entry

Author: IshaanDesai

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## latest
 
+- Fix bug in adaptivity computation when an active simulation with associations is deactivated https://github.com/precice/micro-manager/pull/171
 - Properly handle micro simulation initialization for lazy initialization https://github.com/precice/micro-manager/pull/169
 - Delete the simulation object when the simulation is deactivated https://github.com/precice/micro-manager/pull/167
 - Remove float32 data type restriction for adaptivity data [commit](https://github.com/precice/micro-manager/commit/bfa44ff4d3432c6ac0f3b1311274308d2ec9c2a4)

micro_manager/adaptivity/global_adaptivity.py

@@ -6,7 +6,6 @@
 Note: All ID variables used in the methods of this class are global IDs, unless they have *local* in their name.
 """
 import hashlib
-import importlib
 from copy import deepcopy
 from typing import Dict
 
@@ -307,12 +306,6 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
 
         self._just_deactivated.clear()  # Clear the list of sims deactivated in this step
 
-        # Delete the micro simulation object if it is inactive
-        for i in self._global_ids:
-            if not self._is_sim_active[i]:
-                local_id = self._global_ids.index(i)
-                micro_sims[local_id] = 0
-
         local_sim_is_associated_to = self._sim_is_associated_to[
             self._global_ids[0] : self._global_ids[-1] + 1
         ]
@@ -369,8 +362,13 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
                 )
                 micro_sims[local_id].set_state(state)
 
-        self._sim_is_associated_to = _sim_is_associated_to_updated
-        del _sim_is_associated_to_updated
+        # Delete the micro simulation object if it is inactive
+        for i in self._global_ids:
+            if not self._is_sim_active[i]:
+                local_id = self._global_ids.index(i)
+                micro_sims[local_id] = 0
+
+        self._sim_is_associated_to = np.copy(_sim_is_associated_to_updated)
 
     def _create_tag(self, sim_id: int, src_rank: int, dest_rank: int) -> int:
         """

micro_manager/adaptivity/local_adaptivity.py

@@ -203,11 +203,6 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
 
         self._just_deactivated.clear()  # Clear the list of sims deactivated in this step
 
-        # Delete the inactive micro simulations which have not been activated
-        for i in range(self._is_sim_active.size):
-            if not self._is_sim_active[i]:
-                micro_sims[i] = 0
-
         # Update the set of inactive micro sims
         for i in to_be_activated_ids:
             associated_active_id = self._sim_is_associated_to[i]
@@ -216,3 +211,8 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
             self._sim_is_associated_to[
                 i
             ] = -2  # Active sim cannot have an associated sim
+
+        # Delete the inactive micro simulations which have not been activated
+        for i in range(self._is_sim_active.size):
+            if not self._is_sim_active[i]:
+                micro_sims[i] = 0

micro_manager/micro_manager.py

@@ -150,7 +150,6 @@ def solve(self) -> None:
         - If adaptivity is on, compute micro simulations adaptively.
         """
         t, n = 0, 0
-        t_checkpoint, n_checkpoint = 0, 0
         sim_states_cp = [None] * self._local_number_of_sims
         mem_usage: list = []
 
@@ -161,23 +160,11 @@ def solve(self) -> None:
         dt = min(self._participant.get_max_time_step_size(), self._micro_dt)
 
         first_iteration = True
-        checkpoints_saved = False
 
         while self._participant.is_coupling_ongoing():
 
             dt = min(self._participant.get_max_time_step_size(), self._micro_dt)
 
-            # Write a checkpoint
-            if self._participant.requires_writing_checkpoint():
-                for i in range(self._local_number_of_sims):
-                    sim_states_cp[i] = (
-                        self._micro_sims[i].get_state() if self._micro_sims[i] else None
-                    )
-                t_checkpoint = t
-                n_checkpoint = n
-                first_iteration = True
-                checkpoints_saved = True
-
             if self._is_adaptivity_on:
                 if (self._adaptivity_in_every_implicit_step or first_iteration) and (
                     n % self._adaptivity_n == 0
@@ -188,15 +175,23 @@ def solve(self) -> None:
                         self._data_for_adaptivity,
                     )
 
+                    # Write a checkpoint if a simulation is just activated.
+                    # This checkpoint will be asynchronous to the checkpoints written at the start of the time window.
+                    for i in range(self._local_number_of_sims):
+                        if sim_states_cp[i] is None and self._micro_sims[i]:
+                            sim_states_cp[i] = self._micro_sims[i].get_state()
+
                     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
 
-                        if sim_states_cp[active_id] == None and checkpoints_saved:
-                            sim_states_cp[active_id] = self._micro_sims[
-                                active_id
-                            ].get_state()
+            # Write a checkpoint
+            if self._participant.requires_writing_checkpoint():
+                for i in range(self._local_number_of_sims):
+                    sim_states_cp[i] = (
+                        self._micro_sims[i].get_state() if self._micro_sims[i] else None
+                    )
 
             micro_sims_input = self._read_data_from_precice(dt)
 
@@ -227,23 +222,21 @@ def solve(self) -> None:
 
             self._write_data_to_precice(micro_sims_output)
 
-            t += dt
-            n += 1
-
             self._participant.advance(dt)
 
             # Revert micro simulations to their last checkpoints if required
             if self._participant.requires_reading_checkpoint():
                 for i in range(self._local_number_of_sims):
                     if self._micro_sims[i]:
                         self._micro_sims[i].set_state(sim_states_cp[i])
-                n = n_checkpoint
-                t = t_checkpoint
                 first_iteration = False
 
             if (
                 self._participant.is_time_window_complete()
             ):  # Time window has converged, now micro output can be generated
+                t += dt  # Update time to the end of the time window
+                n += 1  # Update time step to the end of the time window
+
                 if self._micro_sims_have_output:
                     if n % self._micro_n_out == 0:
                         for sim in self._micro_sims:
@@ -260,6 +253,9 @@ def solve(self) -> None:
 
                 self._logger.log_info_rank_zero("Time window {} converged.".format(n))
 
+                # Reset first iteration flag for the next time window
+                first_iteration = True
+
         if self._is_adaptivity_on and n % self._adaptivity_output_n != 0:
             self._adaptivity_controller.log_metrics(n)