Merge branch 'develop' into abstract-micro-sim-class

Author: AdityaGupta716

.github/workflows/run-unit-tests.yml

@@ -20,6 +20,40 @@ jobs:
         run: |
           apt-get -qq update
           apt-get -qq install python3-dev python3-venv git pkg-config
+          apt-get -qq install wget build-essential
+
+      - name: Load Cache OpenMPI 5
+        id: ompi-cache-load
+        uses: actions/cache/restore@v5
+        with:
+          path: ~/openmpi
+          key: openmpi-v5-${{ runner.os }}-build
+
+      - name: Build OpenMPI 5
+        if: steps.ompi-cache-load.outputs.cache-hit != 'true'
+        run: |
+          wget https://download.open-mpi.org/release/open-mpi/v5.0/openmpi-5.0.5.tar.gz
+          tar -xzf openmpi-5.0.5.tar.gz
+          cd openmpi-5.0.5
+          mkdir -p ~/openmpi
+          ./configure --prefix=$HOME/openmpi
+          make -j$(nproc)
+          make install
+
+      - name: Save OpenMPI 5 to cache
+        if: steps.ompi-cache.outputs.cache-hit != 'true'
+        id: ompi-cache-store
+        uses: actions/cache/save@v5
+        with:
+          path: ~/openmpi
+          key: openmpi-v5-${{ runner.os }}-build
+
+      - name: Configure OpenMPI
+        run: |
+          cp -r ~/openmpi/* /usr/local/
+          ldconfig
+          which mpiexec
+          mpiexec --version
 
       - name: Create a virtual environment and install Micro Manager in it
         timeout-minutes: 6
@@ -37,6 +71,16 @@ jobs:
           cd tests/unit
           python3 -m unittest test_micro_manager.py
 
+      - name: Install Micro Manager and run tasking unit test
+        working-directory: micro-manager
+        env:
+          OMPI_ALLOW_RUN_AS_ROOT: "1"
+          OMPI_ALLOW_RUN_AS_ROOT_CONFIRM: "1"
+        run: |
+          . .venv/bin/activate
+          cd tests/unit
+          python3 -m unittest test_tasking.py
+
       - name: Install Micro Manager and run interpolation unit test
         working-directory: micro-manager
         run: |

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## latest
 
+- Added option to use compute instances to reduce memory consumption [#226](https://github.com/precice/micro-manager/pull/226)
+- Added support to run micro simulations in separate processes with workers [#219](https://github.com/precice/micro-manager/pull/219)
 - Added abstraction layers to micro simulations to support more features [#218](https://github.com/precice/micro-manager/pull/218)
 
 ## v0.8.0

docs/configuration.md

@@ -115,6 +115,11 @@ class MicroSimulation: # Name is fixed
         It will be called with frequency set by configuration option `simulation_params: micro_output_n`
         This function is *optional*.
         """
+
+    def get_global_id(self):
+        """
+        Return the assigned global id.
+        """
 ```
 
 For this the default MicroSimulation still serves as the model interface, while the `(set)|(get)_state()` methods
@@ -124,40 +129,43 @@ is likely to be the full order model, while subsequent ones are ROMs.
 
 ```python
 def switching_function(
-    resolutions: np.ndarray,
-    locations: np.ndarray,
+    resolution: int,
+    location: np.ndarray,
     t: float,
-    inputs: list[dict],
+    input: dict,
     prev_output: dict,
-    active: np.ndarray,
-) -> np.ndarray:
+) -> int:
     """
     Switching interface function, use as reference
 
     Parameters
     ----------
-    resolutions : np.array - shape(N,)
-        Array with resolution information as get_sim_class_resolution would return for a sim obj.
-    locations : np.array - shape(N,D)
-        Array with gaussian points for all sims. D is the mesh dimension.
+    resolution : int
+        Current resolution as get_sim_class_resolution would return for the respective sim obj.
+    location : np.array - shape(D,)
+        Array with gaussian points.
     t : float
         Current time in simulation.
-    inputs : list[dict]
-        List of input objects.
-    prev_output : [None, dict-like]
+    input : dict
+        Input object.
+    prev_output : [None, dict]
         Contains the outputs of the previous model evaluation.
-    active : np.array - shape(N,)
-        Bool array indicating whether the model is active or not.
 
+    Returns
+    -------
+    switch_direction: int
+        0 if resolution should not change
+        -1 if resolution should increase
+        1 if resolution should decrease
     """
-    return np.zeros_like(resolutions)
+    return 0
 ```
 
-The switching of models is governed by the `switching_function`.
-The output is expected to be a np.ndarray of shape (N,) and is interpreted in the following manner:
+The switching of models is governed by the `switching_function`, which is evaluated for each micro simulation.
+The output is expected to be an integer and is interpreted in the following manner:
 
-Value | Action
---- | ---
-0 | No resolution change
--1 | Increase model fidelity by one (go back one in list)
-1 | Decrease model fidelity by one (go one ahead in list)
+| Value | Action                                                |
+|-------|-------------------------------------------------------|
+| 0     | No resolution change                                  |
+| -1    | Increase model fidelity by one (go back one in list)  |
+| 1     | Decrease model fidelity by one (go one ahead in list) |

docs/model-adaptivity.md

@@ -7,6 +7,7 @@
 from micro_manager.tools.logging_wrapper import Logger
 from micro_manager.config import Config
 from micro_manager.micro_simulation import MicroSimulationClass
+from micro_manager.model_manager import ModelManager
 
 import numpy as np
 
@@ -17,6 +18,7 @@ def __init__(
         configurator: Config,
         nsims: int,
         micro_problem_cls: MicroSimulationClass,
+        model_manager: ModelManager,
         base_logger: Logger,
         rank: int,
     ) -> None:
@@ -31,6 +33,8 @@ def __init__(
             Number of micro simulations.
         micro_problem_cls : callable
             Class of micro problem.
+        model_manager : object
+            Handles instantiation of micro simulation.
         base_logger : object of class Logger
             Logger object to log messages.
         rank : int
@@ -44,6 +48,7 @@ def __init__(
         self._adaptivity_output_type = configurator.get_adaptivity_output_type()
 
         self._micro_problem_cls = micro_problem_cls
+        self._model_manager = model_manager
 
         self._coarse_tol = 0.0
         self._ref_tol = 0.0

micro_manager/adaptivity/adaptivity.py

@@ -0,0 +1,50 @@
+from .global_adaptivity import GlobalAdaptivityCalculator
+from .global_adaptivity_lb import GlobalAdaptivityLBCalculator
+from .local_adaptivity import LocalAdaptivityCalculator
+from .adaptivity import AdaptivityCalculator
+
+
+def create_adaptivity_calculator(
+    config,
+    local_number_of_sims,
+    global_number_of_sims,
+    global_ids_of_local_sims,
+    participant,
+    logger,
+    rank,
+    comm,
+    micro_problem_cls,
+    model_manager,
+    use_lb,
+) -> AdaptivityCalculator:
+    adaptivity_type = config.get_adaptivity_type()
+
+    if adaptivity_type == "local":
+        return LocalAdaptivityCalculator(
+            config,
+            local_number_of_sims,
+            logger,
+            rank,
+            comm,
+            micro_problem_cls,
+            model_manager,
+        )
+
+    if adaptivity_type == "global":
+        cls = GlobalAdaptivityCalculator
+        if use_lb:
+            cls = GlobalAdaptivityLBCalculator
+
+        return cls(
+            config,
+            global_number_of_sims,
+            global_ids_of_local_sims,
+            participant,
+            logger,
+            rank,
+            comm,
+            micro_problem_cls,
+            model_manager,
+        )
+
+    raise ValueError("Unknown adaptivity type")

micro_manager/adaptivity/adaptivity_selection.py

@@ -16,6 +16,7 @@
 from micro_manager.config import Config
 from micro_manager.tools.logging_wrapper import Logger
 from micro_manager.micro_simulation import MicroSimulationClass
+from micro_manager.model_manager import ModelManager
 
 
 class GlobalAdaptivityCalculator(AdaptivityCalculator):
@@ -29,6 +30,7 @@ def __init__(
         rank: int,
         comm: MPI.Comm,
         micro_problem_cls: MicroSimulationClass,
+        model_manager: ModelManager,
     ) -> None:
         """
         Class constructor.
@@ -51,9 +53,16 @@ def __init__(
             Communicator for MPI.
         micro_problem_cls : callable
             Class of micro problem.
+        model_manager : object of class ModelManager
+            Handles instantiation of the micro simulation.
         """
         super().__init__(
-            configurator, global_number_of_sims, micro_problem_cls, base_logger, rank
+            configurator,
+            global_number_of_sims,
+            micro_problem_cls,
+            model_manager,
+            base_logger,
+            rank,
         )
         self._global_number_of_sims = global_number_of_sims
         self._global_ids = global_ids
@@ -462,7 +471,9 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
         # Only handle activation of simulations on this rank
         for gid in to_be_activated_gids:
             to_be_activated_lid = self._global_ids.index(gid)
-            micro_sims[to_be_activated_lid] = self._micro_problem_cls(gid)
+            micro_sims[to_be_activated_lid] = self._model_manager.get_instance(
+                gid, self._micro_problem_cls
+            )
             assoc_active_gid = self._sim_is_associated_to[gid]
 
             if self._is_sim_on_this_rank[
@@ -499,7 +510,9 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
             local_ids = to_be_activated_map[gid]
             for lid in local_ids:
                 # Create the micro simulation object and set its state
-                micro_sims[lid] = self._micro_problem_cls(self._global_ids[lid])
+                micro_sims[lid] = self._model_manager.get_instance(
+                    self._global_ids[lid], self._micro_problem_cls
+                )
                 micro_sims[lid].set_state(state)
 
         # Delete the micro simulation object if it is inactive

micro_manager/adaptivity/global_adaptivity.py

@@ -13,6 +13,7 @@
 from micro_manager.config import Config
 from micro_manager.micro_simulation import MicroSimulationClass
 from micro_manager.tools.logging_wrapper import Logger
+from micro_manager.model_manager import ModelManager
 
 
 class GlobalAdaptivityLBCalculator(GlobalAdaptivityCalculator):
@@ -26,6 +27,7 @@ def __init__(
         rank: int,
         comm: MPI.Comm,
         micro_problem_cls: MicroSimulationClass,
+        model_manager: ModelManager,
     ) -> None:
         """
         Class constructor.
@@ -48,6 +50,8 @@ def __init__(
             Communicator for MPI.
         micro_problem_cls : callable
             Class of micro problem.
+        model_manager : object of class ModelManager
+            Handles instantiation of the micro simulation.
         """
         super().__init__(
             configurator,
@@ -58,6 +62,7 @@ def __init__(
             rank,
             comm,
             micro_problem_cls,
+            model_manager,
         )
 
         self._base_logger = base_logger
@@ -370,7 +375,9 @@ def _move_active_sims(
         # Create simulations and set them to the received states
         for req in recv_reqs:
             output, gid = req.wait()
-            micro_sims.append(self._micro_problem_cls(gid))
+            micro_sims.append(
+                self._model_manager.get_instance(gid, self._micro_problem_cls)
+            )
             micro_sims[-1].set_state(output)
             self._global_ids.append(gid)
             self._is_sim_on_this_rank[gid] = True

micro_manager/adaptivity/global_adaptivity_lb.py

@@ -12,6 +12,7 @@
 from micro_manager.config import Config
 from micro_manager.micro_simulation import MicroSimulationClass
 from micro_manager.tools.logging_wrapper import Logger
+from micro_manager.model_manager import ModelManager
 
 
 class LocalAdaptivityCalculator(AdaptivityCalculator):
@@ -23,6 +24,7 @@ def __init__(
         rank: int,
         comm: MPI.Comm,
         micro_problem_cls: MicroSimulationClass,
+        model_manager: ModelManager,
     ) -> None:
         """
         Class constructor.
@@ -41,8 +43,12 @@ def __init__(
             Communicator for MPI.
         micro_problem_cls : callable
             Class of micro problem.
+        model_manager : object of class ModelManager
+            Handles instantiation of micro simulation.
         """
-        super().__init__(configurator, num_sims, micro_problem_cls, base_logger, rank)
+        super().__init__(
+            configurator, num_sims, micro_problem_cls, model_manager, base_logger, rank
+        )
         self._comm = comm
 
         # similarity_dists: 2D array having similarity distances between each micro simulation pair
@@ -295,7 +301,7 @@ def _update_inactive_sims(self, micro_sims: list) -> None:
         # Update the set of inactive micro sims
         for i in to_be_activated_ids:
             associated_active_id = self._sim_is_associated_to[i]
-            micro_sims[i] = self._micro_problem_cls(i)
+            micro_sims[i] = self._model_manager.get_instance(i, self._micro_problem_cls)
             micro_sims[i].set_state(micro_sims[associated_active_id].get_state())
             self._sim_is_associated_to[
                 i