ert 17.1.9__py3-none-any.whl → 18.0.1__py3-none-any.whl

ert/run_models/model_factory.py

@@ -21,20 +21,28 @@ from ert.mode_definitions import (
     ENSEMBLE_SMOOTHER_MODE,
     ES_MDA_MODE,
     EVALUATE_ENSEMBLE_MODE,
+    MANUAL_ENIF_UPDATE_MODE,
     MANUAL_UPDATE_MODE,
     TEST_RUN_MODE,
 )
 from ert.validation import ActiveRange
 
-from .ensemble_experiment import EnsembleExperiment
-from .ensemble_information_filter import EnsembleInformationFilter
-from .ensemble_smoother import EnsembleSmoother
-from .evaluate_ensemble import EvaluateEnsemble
+from .ensemble_experiment import EnsembleExperiment, EnsembleExperimentConfig
+from .ensemble_information_filter import (
+    EnsembleInformationFilter,
+    EnsembleInformationFilterConfig,
+)
+from .ensemble_smoother import EnsembleSmoother, EnsembleSmootherConfig
+from .evaluate_ensemble import EvaluateEnsemble, EvaluateEnsembleConfig
 from .initial_ensemble_run_model import DictEncodedDataFrame
-from .manual_update import ManualUpdate
-from .multiple_data_assimilation import MultipleDataAssimilation
+from .manual_update import ManualUpdate, ManualUpdateConfig
+from .manual_update_enif import ManualUpdateEnIF
+from .multiple_data_assimilation import (
+    MultipleDataAssimilation,
+    MultipleDataAssimilationConfig,
+)
 from .run_model import RunModel
-from .single_test_run import SingleTestRun
+from .single_test_run import SingleTestRun, SingleTestRunConfig
 
 if TYPE_CHECKING:
     import numpy.typing as npt
@@ -78,6 +86,8 @@ def create_model(
         )
     if args.mode == MANUAL_UPDATE_MODE:
         return _setup_manual_update(config, args, update_settings, status_queue)
+    if args.mode == MANUAL_ENIF_UPDATE_MODE:
+        return _setup_manual_update_enif(config, args, update_settings, status_queue)
     raise NotImplementedError(f"Run type not supported {args.mode}")
 
 
@@ -122,7 +132,7 @@ def _setup_single_test_run(
         parameter_configs=config.ensemble_config.parameter_configuration,
     )
 
-    return SingleTestRun(
+    runmodel_config = SingleTestRunConfig(
         random_seed=config.random_seed,
         runpath_file=config.runpath_file,
         active_realizations=[True],
@@ -144,6 +154,10 @@ def _setup_single_test_run(
         storage_path=config.ens_path,
         queue_config=config.queue_config.create_local_copy(),
         observations=config.observations,
+    )
+
+    return SingleTestRun(
+        **runmodel_config.model_dump(),
         status_queue=status_queue,
     )
 
@@ -177,7 +191,7 @@ def _setup_ensemble_experiment(
         parameter_configs=config.ensemble_config.parameter_configuration,
     )
 
-    return EnsembleExperiment(
+    runmodel_config = EnsembleExperimentConfig(
         random_seed=config.random_seed,
         runpath_file=config.runpath_file,
         active_realizations=active_realizations,
@@ -199,6 +213,10 @@ def _setup_ensemble_experiment(
         storage_path=config.ens_path,
         queue_config=config.queue_config,
         observations=config.observations,
+    )
+
+    return EnsembleExperiment(
+        **runmodel_config.model_dump(),
         status_queue=status_queue,
     )
 
@@ -210,14 +228,13 @@ def _setup_evaluate_ensemble(
 ) -> EvaluateEnsemble:
     active_realizations = _get_and_validate_active_realizations_list(args, config)
     validate_minimum_realizations(config, active_realizations)
-    return EvaluateEnsemble(
+    runmodel_config = EvaluateEnsembleConfig(
         random_seed=config.random_seed,
         active_realizations=active_realizations,
         ensemble_id=args.ensemble_id,
         minimum_required_realizations=config.analysis_config.minimum_required_realizations,
         storage_path=config.ens_path,
         queue_config=config.queue_config,
-        status_queue=status_queue,
         runpath_file=config.runpath_file,
         user_config_file=Path(config.user_config_file),
         env_vars=config.env_vars,
@@ -228,6 +245,7 @@ def _setup_evaluate_ensemble(
         hooked_workflows=config.hooked_workflows,
         log_path=config.analysis_config.log_path,
     )
+    return EvaluateEnsemble(**runmodel_config.model_dump(), status_queue=status_queue)
 
 
 def _get_and_validate_active_realizations_list(
@@ -267,7 +285,7 @@ def _setup_manual_update(
     active_realizations = _realizations(args, config.runpath_config.num_realizations)
     validate_minimum_realizations(config, active_realizations.tolist())
 
-    return ManualUpdate(
+    runmodel_config = ManualUpdateConfig(
         random_seed=config.random_seed,
         active_realizations=active_realizations.tolist(),
         ensemble_id=args.ensemble_id,
@@ -277,7 +295,6 @@ def _setup_manual_update(
         queue_config=config.queue_config,
         analysis_settings=config.analysis_config.es_settings,
         update_settings=update_settings,
-        status_queue=status_queue,
         runpath_file=config.runpath_file,
         user_config_file=Path(config.user_config_file),
         env_vars=config.env_vars,
@@ -290,6 +307,44 @@ def _setup_manual_update(
         ert_templates=config.ert_templates,
         observations=config.observations,
     )
+    return ManualUpdate(**runmodel_config.model_dump(), status_queue=status_queue)
+
+
+def _setup_manual_update_enif(
+    config: ErtConfig,
+    args: Namespace,
+    update_settings: ObservationSettings,
+    status_queue: SimpleQueue[StatusEvents],
+) -> ManualUpdate:
+    active_realizations = _realizations(args, config.runpath_config.num_realizations)
+
+    return ManualUpdateEnIF(
+        random_seed=config.random_seed,
+        active_realizations=active_realizations.tolist(),
+        ensemble_id=args.ensemble_id,
+        minimum_required_realizations=config.analysis_config.minimum_required_realizations,
+        target_ensemble=args.target_ensemble,
+        config=config,
+        storage_path=config.ens_path,
+        queue_config=config.queue_config,
+        analysis_settings=config.analysis_config.es_settings,
+        update_settings=update_settings,
+        status_queue=status_queue,
+        runpath_file=config.runpath_file,
+        design_matrix=config.analysis_config.design_matrix,
+        parameter_configuration=config.ensemble_config.parameter_configuration,
+        response_configuration=config.ensemble_config.response_configuration,
+        ert_templates=config.ert_templates,
+        user_config_file=Path(config.user_config_file),
+        env_vars=config.env_vars,
+        env_pr_fm_step=config.env_pr_fm_step,
+        runpath_config=config.runpath_config,
+        forward_model_steps=config.forward_model_steps,
+        substitutions=config.substitutions,
+        hooked_workflows=config.hooked_workflows,
+        log_path=config.analysis_config.log_path,
+        observations=config.observations,
+    )
 
 
 def _setup_ensemble_smoother(
@@ -300,7 +355,7 @@ def _setup_ensemble_smoother(
 ) -> EnsembleSmoother:
     active_realizations = _get_and_validate_active_realizations_list(args, config)
     validate_minimum_realizations(config, active_realizations)
-    if len(active_realizations) < 2:
+    if sum(active_realizations) < 2:
         raise ConfigValidationError(
             "Number of active realizations must be at least 2 for an update step"
         )
@@ -311,7 +366,7 @@ def _setup_ensemble_smoother(
         require_updateable_param=True,
     )
 
-    return EnsembleSmoother(
+    runmodel_config = EnsembleSmootherConfig(
         target_ensemble=args.target_ensemble,
         experiment_name=getattr(args, "experiment_name", ""),
         active_realizations=active_realizations,
@@ -321,7 +376,6 @@ def _setup_ensemble_smoother(
         queue_config=config.queue_config,
         analysis_settings=config.analysis_config.es_settings,
         update_settings=update_settings,
-        status_queue=status_queue,
         runpath_file=config.runpath_file,
         design_matrix=design_matrix,
         parameter_configuration=parameter_configs,
@@ -337,6 +391,7 @@ def _setup_ensemble_smoother(
         log_path=config.analysis_config.log_path,
         observations=config.observations,
     )
+    return EnsembleSmoother(**runmodel_config.model_dump(), status_queue=status_queue)
 
 
 def _setup_ensemble_information_filter(
@@ -347,7 +402,7 @@ def _setup_ensemble_information_filter(
 ) -> EnsembleInformationFilter:
     active_realizations = _get_and_validate_active_realizations_list(args, config)
     validate_minimum_realizations(config, active_realizations)
-    if len(active_realizations) < 2:
+    if sum(active_realizations) < 2:
         raise ConfigValidationError(
             "Number of active realizations must be at least 2 for an update step"
         )
@@ -357,7 +412,7 @@ def _setup_ensemble_information_filter(
         parameter_configs=config.ensemble_config.parameter_configuration,
     )
 
-    return EnsembleInformationFilter(
+    runmodel_config = EnsembleInformationFilterConfig(
         target_ensemble=args.target_ensemble,
         experiment_name=getattr(args, "experiment_name", ""),
         active_realizations=active_realizations,
@@ -367,7 +422,6 @@ def _setup_ensemble_information_filter(
         queue_config=config.queue_config,
         analysis_settings=config.analysis_config.es_settings,
         update_settings=update_settings,
-        status_queue=status_queue,
         runpath_file=config.runpath_file,
         design_matrix=design_matrix,
         parameter_configuration=parameter_configs,
@@ -383,6 +437,9 @@ def _setup_ensemble_information_filter(
         log_path=config.analysis_config.log_path,
         observations=config.observations,
     )
+    return EnsembleInformationFilter(
+        **runmodel_config.model_dump(), status_queue=status_queue
+    )
 
 
 def _determine_restart_info(args: Namespace) -> tuple[bool, str | None]:
@@ -413,7 +470,7 @@ def _setup_multiple_data_assimilation(
     restart_run, prior_ensemble = _determine_restart_info(args)
     active_realizations = _get_and_validate_active_realizations_list(args, config)
     validate_minimum_realizations(config, active_realizations)
-    if len(active_realizations) < 2:
+    if sum(active_realizations) < 2:
         raise ConfigValidationError(
             "Number of active realizations must be at least 2 for an update step"
         )
@@ -424,7 +481,7 @@ def _setup_multiple_data_assimilation(
         require_updateable_param=True,
     )
 
-    return MultipleDataAssimilation(
+    runmodel_config = MultipleDataAssimilationConfig(
         random_seed=config.random_seed,
         active_realizations=active_realizations,
         target_ensemble=_iterative_ensemble_format(args),
@@ -435,7 +492,6 @@ def _setup_multiple_data_assimilation(
         experiment_name=args.experiment_name,
         queue_config=config.queue_config,
         update_settings=update_settings,
-        status_queue=status_queue,
         storage_path=config.ens_path,
         analysis_settings=config.analysis_config.es_settings,
         runpath_file=config.runpath_file,
@@ -453,6 +509,9 @@ def _setup_multiple_data_assimilation(
         log_path=config.analysis_config.log_path,
         observations=config.observations,
     )
+    return MultipleDataAssimilation(
+        **runmodel_config.model_dump(), status_queue=status_queue
+    )
 
 
 def _realizations(

ert/run_models/multiple_data_assimilation.py

@@ -14,8 +14,11 @@ from ert.config import (
     ResponseConfig,
 )
 from ert.ensemble_evaluator import EvaluatorServerConfig
-from ert.run_models.initial_ensemble_run_model import InitialEnsembleRunModel
-from ert.run_models.update_run_model import UpdateRunModel
+from ert.run_models.initial_ensemble_run_model import (
+    InitialEnsembleRunModel,
+    InitialEnsembleRunModelConfig,
+)
+from ert.run_models.update_run_model import UpdateRunModel, UpdateRunModelConfig
 from ert.storage import Ensemble
 from ert.trace import tracer
 
@@ -28,18 +31,25 @@ logger = logging.getLogger(__name__)
 MULTIPLE_DATA_ASSIMILATION_GROUP = "Parameter update"
 
 
-class MultipleDataAssimilation(UpdateRunModel, InitialEnsembleRunModel):
-    """
-    Run multiple data assimilation (MDA) ensemble smoother with custom weights.
-    """
-
+class MultipleDataAssimilationConfig(
+    InitialEnsembleRunModelConfig, UpdateRunModelConfig
+):
     default_weights: ClassVar[str] = "4, 2, 1"
     restart_run: bool
     prior_ensemble_id: str | None
     weights: str
 
+
+class MultipleDataAssimilation(
+    UpdateRunModel, InitialEnsembleRunModel, MultipleDataAssimilationConfig
+):
+    """
+    Run multiple data assimilation (MDA) ensemble smoother with custom weights.
+    """
+
     _parsed_weights: list[float] = PrivateAttr()
     _total_iterations: int = PrivateAttr(default=2)
+    _start_iteration: int = PrivateAttr(default=0)
 
     def model_post_init(self, ctx: Any) -> None:
         super().model_post_init(ctx)
@@ -56,7 +66,7 @@ class MultipleDataAssimilation(UpdateRunModel, InitialEnsembleRunModel):
         elif not self.experiment_name:
             raise ValueError("For non-restart run, experiment name must be set")
 
-        self.start_iteration = start_iteration
+        self._start_iteration = start_iteration
         self._total_iterations = total_iterations
 
     @tracer.start_as_current_span(f"{__name__}.run_experiment")
@@ -80,10 +90,10 @@ class MultipleDataAssimilation(UpdateRunModel, InitialEnsembleRunModel):
                 self.set_env_key("_ERT_EXPERIMENT_ID", str(experiment.id))
                 self.set_env_key("_ERT_ENSEMBLE_ID", str(prior.id))
                 assert isinstance(prior, Ensemble)
-                if self.start_iteration != prior.iteration + 1:
+                if self._start_iteration != prior.iteration + 1:
                     raise ValueError(
                         "Experiment misconfigured, got starting "
-                        f"iteration: {self.start_iteration},"
+                        f"iteration: {self._start_iteration},"
                         f"restart iteration = {prior.iteration + 1}"
                     )
                 target_experiment = self._storage.create_experiment(
@@ -94,6 +104,7 @@ class MultipleDataAssimilation(UpdateRunModel, InitialEnsembleRunModel):
                     name=f"Restart from {prior.name}",
                     templates=self.ert_templates,
                 )
+
             except (KeyError, ValueError) as err:
                 raise ErtRunError(
                     f"Prior ensemble with ID: {id_} does not exists"

ert/run_models/run_model.py

@@ -3,20 +3,21 @@ from __future__ import annotations
 import asyncio
 import concurrent.futures
 import copy
-import dataclasses
 import functools
 import logging
 import os
 import queue
 import shutil
 import threading
-import time
 import traceback
 import uuid
+import warnings
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Callable, Generator, MutableSequence
 from contextlib import contextmanager
+from dataclasses import dataclass
+from datetime import datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Protocol, cast
 
@@ -24,8 +25,12 @@ import numpy as np
 from pydantic import PrivateAttr, field_validator
 from pydantic_core.core_schema import ValidationInfo
 
-from _ert.events import EEEvent, EESnapshot, EESnapshotUpdate
-from ert.base_model_context import BaseModelWithContextSupport
+from _ert.events import (
+    EEEvent,
+    EESnapshot,
+    EESnapshotUpdate,
+    EnsembleEvaluationWarning,
+)
 from ert.config import (
     ConfigValidationError,
     DesignMatrix,
@@ -37,7 +42,6 @@ from ert.config import (
     PostSimulationFixtures,
     PreSimulationFixtures,
     QueueConfig,
-    QueueSystem,
     Workflow,
     create_workflow_fixtures_from_hooked,
 )
@@ -49,7 +53,7 @@ from ert.ensemble_evaluator import (
     Realization,
     WarningEvent,
 )
-from ert.ensemble_evaluator.evaluator import UserCancelled
+from ert.ensemble_evaluator.evaluator import ParallelismViolation, UserCancelled
 from ert.ensemble_evaluator.snapshot import EnsembleSnapshot
 from ert.ensemble_evaluator.state import (
     REALIZATION_STATE_FAILED,
@@ -67,9 +71,16 @@ from ert.utils import log_duration
 from ert.warnings import PostSimulationWarning, capture_specific_warning
 from ert.workflow_runner import WorkflowRunner
 
+from ..base_model_context import BaseModelWithContextSupport
 from ..run_arg import RunArg
 from ._create_run_path import create_run_path
-from .event import EndEvent, FullSnapshotEvent, SnapshotUpdateEvent, StatusEvents
+from .event import (
+    EndEvent,
+    FullSnapshotEvent,
+    SnapshotUpdateEvent,
+    StartEvent,
+    StatusEvents,
+)
 
 if TYPE_CHECKING:
     from ert.plugins import ErtRuntimePlugins
@@ -137,17 +148,16 @@ class StartSimulationsThreadFn(Protocol):
     ) -> None: ...
 
 
-@dataclasses.dataclass
+@dataclass
 class RunModelAPI:
     experiment_name: str
     supports_rerunning_failed_realizations: bool
     start_simulations_thread: StartSimulationsThreadFn
     cancel: Callable[[], None]
-    get_runtime: Callable[[], int]
     has_failed_realizations: Callable[[], bool]
 
 
-class RunModel(BaseModelWithContextSupport, ABC):
+class RunModelConfig(BaseModelWithContextSupport):
     storage_path: str
     runpath_file: Path
     user_config_file: Path
@@ -165,9 +175,9 @@ class RunModel(BaseModelWithContextSupport, ABC):
     minimum_required_realizations: int = 0
     supports_rerunning_failed_realizations: ClassVar[bool] = False
 
+
+class RunModel(RunModelConfig, ABC):
     # Private attributes initialized in model_post_init
-    _start_time: int | None = PrivateAttr(None)
-    _stop_time: int | None = PrivateAttr(None)
     _initial_realizations_mask: list[bool] = PrivateAttr()
     _completed_realizations_mask: list[bool] = PrivateAttr(default_factory=list)
     _storage: Storage = PrivateAttr()
@@ -179,6 +189,8 @@ class RunModel(BaseModelWithContextSupport, ABC):
     _is_rerunning_failed_realizations: bool = PrivateAttr(False)
     _run_paths: Runpaths = PrivateAttr()
     _total_iterations: int = PrivateAttr(default=1)
+    _start_iteration: int = PrivateAttr(default=0)
+    _max_parallelism_violation: ParallelismViolation = ParallelismViolation()
 
     def __init__(
         self,
@@ -198,21 +210,20 @@ class RunModel(BaseModelWithContextSupport, ABC):
         self._completed_realizations_mask = [False] * len(self.active_realizations)
         self._storage = open_storage(self.storage_path, mode="w")
         self._rng = np.random.default_rng(self.random_seed)
-        self._model_config = self.runpath_config
+        self._start_iteration = self.start_iteration
 
         self._run_paths = Runpaths(
-            jobname_format=self._model_config.jobname_format_string,
-            runpath_format=self._model_config.runpath_format_string,
+            jobname_format=self.runpath_config.jobname_format_string,
+            runpath_format=self.runpath_config.runpath_format_string,
             filename=str(self.runpath_file),
             substitutions=self.substitutions,
-            eclbase=self._model_config.eclbase_format_string,
+            eclbase=self.runpath_config.eclbase_format_string,
         )
 
     @property
     def api(self) -> RunModelAPI:
         return RunModelAPI(
             experiment_name=self.name(),
-            get_runtime=self.get_runtime,
             start_simulations_thread=self.start_simulations_thread,
             has_failed_realizations=self.has_failed_realizations,
             supports_rerunning_failed_realizations=self.supports_rerunning_failed_realizations,
@@ -330,10 +341,6 @@ class RunModel(BaseModelWithContextSupport, ABC):
     def send_event(self, event: StatusEvents) -> None:
         self._status_queue.put(event)
 
-    @property
-    def queue_system(self) -> QueueSystem:
-        return self.queue_config.queue_system
-
     @property
     def ensemble_size(self) -> int:
         return len(self._initial_realizations_mask)
@@ -396,9 +403,9 @@ class RunModel(BaseModelWithContextSupport, ABC):
         def handle_captured_event(message: Warning | str) -> None:
             self.send_event(WarningEvent(msg=str(message)))
 
+        start_timestamp = datetime.now()
         try:
-            self._start_time = int(time.time())
-            self._stop_time = None
+            self.send_event(StartEvent(timestamp=start_timestamp))
             with (
                 capture_specific_warning(PostSimulationWarning, handle_captured_event),
                 captured_logs(error_messages),
@@ -453,7 +460,6 @@ class RunModel(BaseModelWithContextSupport, ABC):
         finally:
             self._storage.close()
             self._clean_env_context()
-            self._stop_time = int(time.time())
             self.send_event(
                 EndEvent(
                     failed=failed,
@@ -468,6 +474,10 @@ class RunModel(BaseModelWithContextSupport, ABC):
                     ),
                 )
             )
+            logger.info(
+                "Experiment run finished in: "
+                f"{(datetime.now() - start_timestamp).total_seconds():g}s"
+            )
 
     @abstractmethod
     def run_experiment(
@@ -489,13 +499,6 @@ class RunModel(BaseModelWithContextSupport, ABC):
             return f"{exception}\n{msg}"
         return f"{exception}\n{traceback}\n{msg}"
 
-    def get_runtime(self) -> int:
-        if self._start_time is None:
-            return 0
-        elif self._stop_time is None:
-            return round(time.time() - self._start_time)
-        return self._stop_time - self._start_time
-
     def get_current_status(self) -> dict[str, int]:
         status: dict[str, int] = defaultdict(int)
         if self._iter_snapshot.keys():
@@ -609,6 +612,8 @@ class RunModel(BaseModelWithContextSupport, ABC):
                     snapshot=copy.deepcopy(snapshot),
                 )
             )
+        elif type(event) is EnsembleEvaluationWarning:
+            self.send_event(event)
 
     async def run_ensemble_evaluator_async(
         self,
@@ -639,6 +644,10 @@ class RunModel(BaseModelWithContextSupport, ABC):
         finally:
             await evaluator_task
 
+        self._max_parallelism_violation = max(
+            self._max_parallelism_violation, evaluator.max_parallelism_violation
+        )
+
         logger.debug("tasks complete")
 
         if self._end_event.is_set():
@@ -704,7 +713,8 @@ class RunModel(BaseModelWithContextSupport, ABC):
         run_paths = []
         active_realizations = np.where(self.active_realizations)[0]
         for iteration in range(
-            self.start_iteration, self._total_iterations + self.start_iteration
+            self._start_iteration,
+            self._total_iterations + self._start_iteration,
         ):
             run_paths.extend(self._run_paths.get_paths(active_realizations, iteration))
         return run_paths
@@ -772,7 +782,7 @@ class RunModel(BaseModelWithContextSupport, ABC):
             env_pr_fm_step=self.env_pr_fm_step,
             forward_model_steps=self.forward_model_steps,
             substitutions=self.substitutions,
-            parameters_file=self._model_config.gen_kw_export_name,
+            parameters_file=self.runpath_config.gen_kw_export_name,
             runpaths=self._run_paths,
             context_env=self._context_env,
         )
@@ -818,7 +828,17 @@ class RunModel(BaseModelWithContextSupport, ABC):
             f"Experiment run ended with number of realizations failing: "
             f"{len(starting_realizations) - num_successful_realizations}"
         )
-        logger.info(f"Experiment run finished in: {self.get_runtime()}s")
+
+        # 0 means no violation
+        if self._max_parallelism_violation.amount > 0 and isinstance(
+            self._max_parallelism_violation.message, str
+        ):
+            warnings.warn(
+                self._max_parallelism_violation.message,
+                PostSimulationWarning,
+                stacklevel=1,
+            )
+
         self.run_workflows(
             fixtures=PostSimulationFixtures(
                 storage=self._storage,

ert/run_models/single_test_run.py

@@ -3,11 +3,17 @@ from __future__ import annotations
 from pydantic import Field
 
 from ert.run_models import EnsembleExperiment
+from ert.run_models.ensemble_experiment import EnsembleExperimentConfig
 
 SINGLE_TEST_RUN_GROUP = "Forward model evaluation"
 
 
-class SingleTestRun(EnsembleExperiment):
+class SingleTestRunConfig(EnsembleExperimentConfig):
+    active_realizations: list[bool] = Field(default_factory=lambda: [True])
+    minimum_required_realizations: int = 1
+
+
+class SingleTestRun(EnsembleExperiment, SingleTestRunConfig):
     """
     Single test is equivalent to EnsembleExperiment, in that it
     samples the prior and evaluates it.<br>There are two key differences:<br>
@@ -15,9 +21,6 @@ class SingleTestRun(EnsembleExperiment):
     2) Only a <b>single realization</b> (realization-0) is run<br>
     """
 
-    active_realizations: list[bool] = Field(default_factory=lambda: [True])
-    minimum_required_realizations: int = 1
-
     @classmethod
     def name(cls) -> str:
         return "Single realization test-run"

ert/run_models/update_run_model.py

@@ -27,15 +27,17 @@ from ert.run_models.event import (
     RunModelUpdateBeginEvent,
     RunModelUpdateEndEvent,
 )
-from ert.run_models.run_model import ErtRunError, RunModel
+from ert.run_models.run_model import ErtRunError, RunModel, RunModelConfig
 from ert.storage import Ensemble, LocalExperiment
 
 
-class UpdateRunModel(RunModel):
+class UpdateRunModelConfig(RunModelConfig):
     target_ensemble: str
     analysis_settings: ESSettings
     update_settings: ObservationSettings
 
+
+class UpdateRunModel(RunModel, UpdateRunModelConfig):
     @abstractmethod
     def update_ensemble_parameters(
         self, prior: Ensemble, posterior: Ensemble, weight: float

ert/runpaths.py

@@ -101,14 +101,13 @@ class Runpaths:
         with open(self.runpath_list_filename, "w", encoding="utf-8") as filehandle:
             for iteration in iteration_numbers:
                 for realization in realization_numbers:
-                    job_name_or_eclbase = self.substitutions.substitute_real_iter(
-                        self._eclbase or self._jobname_format,
-                        realization,
-                        iteration,
+                    real_iter_substituter = self.substitutions.real_iter_substituter(
+                        realization, iteration
                     )
-                    runpath = self.substitutions.substitute_real_iter(
-                        self._runpath_format, realization, iteration
+                    job_name_or_eclbase = real_iter_substituter.substitute(
+                        self._eclbase or self._jobname_format,
                     )
+                    runpath = real_iter_substituter.substitute(self._runpath_format)
 
                     filehandle.write(
                         f"{realization:03d}  {runpath}  "