Fix adaptivity calling for explicit coupling

.github/workflows/run-adaptivity-tests-parallel.yml

@@ -43,7 +43,7 @@ jobs:
         working-directory: micro-manager/tests/integration/test_unit_cube
         run: |
           mpiexec -n 2 --allow-run-as-root micro-manager-precice micro-manager-config-global-adaptivity-parallel.json &
-          python3 unit_cube.py
+          python3 unit_cube.py 2
 
   adaptivity_unit_tests_parallel:
     name: Adaptivity unit tests in parallel

.github/workflows/run-adaptivity-tests-serial.yml

@@ -34,14 +34,14 @@ jobs:
         working-directory: micro-manager/tests/integration/test_unit_cube
         run: |
           micro-manager-precice micro-manager-config-local-adaptivity.json &
-          python3 unit_cube.py
+          python3 unit_cube.py 2
 
       - name: Run integration test with global adaptivity
         timeout-minutes: 3
         working-directory: micro-manager/tests/integration/test_unit_cube
         run: |
           micro-manager-precice micro-manager-config-global-adaptivity.json &
-          python3 unit_cube.py
+          python3 unit_cube.py 2
 
   adaptivity_unit_tests_serial:
     name: Run adaptivity unit tests in serial

.github/workflows/run-domain-decomposition-tests.yml

@@ -8,50 +8,6 @@ on:
     branches:
       - "*"
 jobs:
-  domain_decomposition_integration_tests:
-    name: Run domain decomposition integration tests
-    runs-on: ubuntu-latest
-    container: precice/precice:nightly
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          path: micro-manager
-
-      - name: Install sudo for MPI
-        working-directory: micro-manager
-        run: |
-          apt-get -qq update
-          apt-get -qq install sudo
-
-      - name: Use mpi4py
-        uses: mpi4py/setup-mpi@v1
-
-      - name: Install Dependencies
-        working-directory: micro-manager
-        run: |
-          apt-get -qq update
-          apt-get -qq install python3-dev python3-pip git python-is-python3 pkg-config
-          pip3 install --upgrade pip
-
-      - name: Install micro-manager
-        working-directory: micro-manager
-        run: pip3 install .
-
-      - name: Run integration test (2 processes)
-        timeout-minutes: 3
-        working-directory: micro-manager/tests/integration/test_unit_cube
-        run: |
-          mpiexec -n 2 --allow-run-as-root micro-manager-precice micro-manager-config-parallel-1.json &
-          python3 unit_cube.py
-
-      - name: Run integration test (6 processes)
-        timeout-minutes: 3
-        working-directory: micro-manager/tests/integration/test_unit_cube
-        run: |
-          mpiexec -n 6 --oversubscribe --allow-run-as-root micro-manager-precice micro-manager-config-parallel-2.json &
-          python3 unit_cube.py
-
   domain_decomposition_unit_tests:
     name: Run domain decomposition unit tests
     runs-on: ubuntu-latest

CHANGELOG.md

@@ -2,6 +2,7 @@
 
 ## latest
 
+- Fix bug in calling of the adaptivity computation for explicit coupling scenarios https://github.com/precice/micro-manager/pull/145
 - Fix bug in handling of vector data returned by the MicroSimulation `solve()` method, for scenarios with adaptivity https://github.com/precice/micro-manager/pull/143
 - Remove the `scalar` and `vector` keyword values from data names in configuration https://github.com/precice/micro-manager/pull/142
 - Set default logger to stdout and add output directory setting option for file loggers https://github.com/precice/micro-manager/pull/139

micro_manager/micro_manager.py

@@ -162,6 +162,7 @@ def solve(self) -> None:
                 )
 
         adaptivity_cpu_time = 0.0
+        first_iteration = True
 
         while self._participant.is_coupling_ongoing():
 
@@ -173,30 +174,29 @@ def solve(self) -> None:
                     sim_states_cp[i] = self._micro_sims[i].get_state()
                 t_checkpoint = t
                 n_checkpoint = n
+                first_iteration = True
 
-                if self._is_adaptivity_on:
-                    if not self._adaptivity_in_every_implicit_step:
-                        start_time = time.process_time()
-                        self._adaptivity_controller.compute_adaptivity(
-                            dt,
-                            self._micro_sims,
-                            self._data_for_adaptivity,
-                        )
+            if self._is_adaptivity_on:
+                if self._adaptivity_in_every_implicit_step or first_iteration:
+                    start_time = time.process_time()
+                    self._adaptivity_controller.compute_adaptivity(
+                        dt,
+                        self._micro_sims,
+                        self._data_for_adaptivity,
+                    )
 
-                        end_time = time.process_time()
+                    end_time = time.process_time()
 
-                        adaptivity_cpu_time = end_time - start_time
+                    adaptivity_cpu_time = end_time - start_time
 
-                        # Only checkpoint the adaptivity configuration if adaptivity is computed
-                        # once in every time window
-                        self._adaptivity_controller.write_checkpoint()
+                    # Only checkpoint the adaptivity configuration if adaptivity is computed
+                    # once in every time window
+                    self._adaptivity_controller.write_checkpoint()
 
-                        active_sim_ids = (
-                            self._adaptivity_controller.get_active_sim_ids()
-                        )
+                    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
+                    for active_id in active_sim_ids:
+                        self._micro_sims_active_steps[active_id] += 1
 
             micro_sims_input = self._read_data_from_precice(dt)
 
@@ -243,6 +243,7 @@ def solve(self) -> None:
                     self._micro_sims[i].set_state(sim_states_cp[i])
                 n = n_checkpoint
                 t = t_checkpoint
+                first_iteration = False
 
                 # If adaptivity is computed only once per time window, the states of sims need to be reset too
                 if self._is_adaptivity_on:
@@ -462,12 +463,7 @@ def initialize(self) -> None:
 
         if is_initial_data_required and not is_initial_data_available:
             raise Exception(
-                "The initialize() method of the Micro simulation requires initial data, but no initial data has been provided."
-            )
-
-        if not is_initial_data_required and is_initial_data_available:
-            warn(
-                "The initialize() method is only allowed to return data which is required for the adaptivity calculation."
+                "The initialize() method of the Micro simulation requires initial data, but no initial macro data has been provided."
             )
 
         # Get initial data from micro simulations if initialize() method exists

tests/integration/test_unit_cube/clean-test.sh

@@ -1,12 +1,9 @@
 rm -fv *-events-summary.json
 rm -fv *-events.json
 rm -fv *.log
-rm -r -fv precice-run/
-rm -r -fv precice-profiling/
+rm -rfv precice-run/ precice-profiling/
 rm -fv *.vtk
 rm -fv *.out
 rm -fv *.err
-rm -fv output/*.vtu
-rm -fv output/*.pvtu
-rm -r -fv __pycache__
+rm -rfv __pycache__ output/ .venv/ adaptivity_output/
 rm -fv *.csv

tests/integration/test_unit_cube/micro-manager-config-global-adaptivity-parallel.json

@@ -4,8 +4,8 @@
     "coupling_params": {
         "precice_config_file_name": "precice-config.xml",
         "macro_mesh_name": "macro-cube-mesh",
-        "read_data_names": ["macro-scalar-data", "macro-vector-data"],
-        "write_data_names": ["micro-scalar-data", "micro-vector-data"]
+        "write_data_names": ["micro-data-1", "micro-data-2"],
+        "read_data_names": ["macro-data-1"]
     },
     "simulation_params": {
         "micro_dt": 1.0,
@@ -14,11 +14,11 @@
         "adaptivity": "True",
         "adaptivity_settings": {
             "type": "global",
-            "data": ["macro-scalar-data", "micro-vector-data"],
-            "history_param": 0.5,
+            "data": ["micro-data-1", "micro-data-2"],
+            "history_param": 1.0,
             "coarsening_constant": 0.3,
             "refining_constant": 0.4,
-            "every_implicit_iteration": "True",
+            "every_implicit_iteration": "False",
 	        "output_cpu_time": "True"
         }
     },

tests/integration/test_unit_cube/micro-manager-config-global-adaptivity.json

@@ -3,16 +3,16 @@
     "coupling_params": {
         "precice_config_file_name": "precice-config.xml",
         "macro_mesh_name": "macro-cube-mesh",
-        "read_data_names": ["macro-scalar-data", "macro-vector-data"],
-        "write_data_names": ["micro-scalar-data", "micro-vector-data"]
+        "write_data_names": ["micro-data-1", "micro-data-2"],
+        "read_data_names": ["macro-data-1"]
     },
     "simulation_params": {
         "micro_dt": 1.0,
         "macro_domain_bounds": [0, 1, 0, 1, 0, 1],
         "adaptivity": "True",
         "adaptivity_settings": {
             "type": "global",
-            "data": ["macro-scalar-data", "macro-vector-data"],
+            "data": ["micro-data-1", "micro-data-2"],
             "history_param": 0.5,
             "coarsening_constant": 0.3,
             "refining_constant": 0.4,

tests/integration/test_unit_cube/micro-manager-config-load-balancing.json

@@ -0,0 +1,34 @@
+{
+    "micro_file_name": "micro_dummy",
+    "output_dir": "adaptivity_output",
+    "coupling_params": {
+        "precice_config_file_name": "precice-config.xml",
+        "macro_mesh_name": "macro-cube-mesh",
+        "read_data_names": ["macro-scalar-data", "macro-vector-data"],
+        "write_data_names": ["micro-scalar-data", "micro-vector-data"]
+    },
+    "simulation_params": {
+        "micro_dt": 1.0,
+        "macro_domain_bounds": [0, 1, 0, 1, 0, 1],
+        "decomposition": [2, 1, 1],
+        "adaptivity": "True",
+        "adaptivity_settings": {
+            "type": "global",
+            "load_balancing": "True",
+            "load_balancing_settings": {
+                "load_balancing_n": 5,
+                "two_step_load_balancing": "True",
+                "balancing_threshold": 2
+            },
+            "data": ["macro-scalar-data", "micro-vector-data"],
+            "history_param": 0.5,
+            "coarsening_constant": 0.3,
+            "refining_constant": 0.4,
+            "every_implicit_iteration": "True",
+	        "output_cpu_time": "True"
+        }
+    },
+    "diagnostics": {
+        "output_micro_sim_solve_time": "True"
+    }
+}

tests/integration/test_unit_cube/micro-manager-config-local-adaptivity.json

@@ -3,16 +3,16 @@
     "coupling_params": {
         "precice_config_file_name": "precice-config.xml",
         "macro_mesh_name": "macro-cube-mesh",
-        "read_data_names": ["macro-scalar-data", "macro-vector-data"],
-        "write_data_names": ["micro-scalar-data", "micro-vector-data"]
+        "write_data_names": ["micro-data-1", "micro-data-2"],
+        "read_data_names": ["macro-data-1"]
     },
     "simulation_params": {
         "micro_dt": 1.0,
         "macro_domain_bounds": [0, 1, 0, 1, 0, 1],
         "adaptivity": "True",
         "adaptivity_settings": {
             "type": "local",
-            "data": ["macro-scalar-data", "macro-vector-data"],
+            "data": ["micro-data-1", "micro-data-2"],
             "history_param": 0.5,
             "coarsening_constant": 0.3,
             "refining_constant": 0.4,

tests/integration/test_unit_cube/micro-manager-config-parallel-1.json

@@ -3,8 +3,8 @@
     "coupling_params": {
         "precice_config_file_name": "precice-config.xml",
         "macro_mesh_name": "macro-cube-mesh",
-        "read_data_names": ["macro-scalar-data", "macro-vector-data"],
-        "write_data_names": ["micro-scalar-data", "micro-vector-data"]
+        "write_data_names": ["micro-data-1", "micro-data-2"],
+        "read_data_names": ["macro-data-1"]
     },
     "simulation_params": {
         "micro_dt": 1.0,

tests/integration/test_unit_cube/micro-manager-config-parallel-2.json

@@ -3,8 +3,8 @@
     "coupling_params": {
         "precice_config_file_name": "precice-config.xml",
         "macro_mesh_name": "macro-cube-mesh",
-        "read_data_names": ["macro-scalar-data", "macro-vector-data"],
-        "write_data_names": ["micro-scalar-data", "micro-vector-data"]
+        "write_data_names": ["micro-data-1", "micro-data-2"],
+        "read_data_names": ["macro-data-1"]
     },
     "simulation_params": {
         "micro_dt": 1.0,

tests/integration/test_unit_cube/micro_dummy.py

@@ -2,6 +2,9 @@
 Micro simulation
 In this script we solve a dummy micro problem to just show the working of the macro-micro coupling
 """
+import copy
+import random
+import time
 
 
 class MicroSimulation:
@@ -10,28 +13,38 @@ def __init__(self, sim_id):
         Constructor of MicroSimulation class.
         """
         self._sim_id = sim_id
-        self._micro_scalar_data = None
-        self._micro_vector_data = None
-        self._checkpoint = None
+
+        sim_types = [4, 88, 37, 12, 1, 23, 134]
+
+        self._this_sim_type = random.choice(sim_types)
+
+        # Artificial state of 100 floats
+        self._state = [x * 0.1 for x in range(100)]
 
     def initialize(self):
-        self._micro_scalar_data = 0
-        self._micro_vector_data = []
-        self._checkpoint = 0
+        return {
+            "micro-data-1": self._this_sim_type * 0.5,
+            "micro-data-2": [
+                self._this_sim_type * 2,
+                self._this_sim_type * 3,
+                self._this_sim_type * 4,
+            ],
+        }
 
     def solve(self, macro_data, dt):
-        assert dt != 0
-        self._micro_vector_data = macro_data["macro-vector-data"]
-        self._micro_scalar_data = macro_data["macro-scalar-data"]
+        time.sleep(self._this_sim_type * 0.001)
 
         return {
-            "micro-scalar-data": self._micro_scalar_data,
-            "micro-vector-data": self._micro_vector_data,
+            "micro-data-1": self._this_sim_type * 0.5,
+            "micro-data-2": [
+                self._this_sim_type * 2,
+                self._this_sim_type * 3,
+                self._this_sim_type * 4,
+            ],
         }
 
     def get_state(self):
-        return [self._micro_scalar_data, self._micro_vector_data]
+        return copy.deepcopy(self._state)
 
     def set_state(self, state):
-        self._micro_scalar_data = state[0]
-        self._micro_vector_data = state[0]
+        self._state = copy.deepcopy(state)