diff --git a/src/ert/__main__.py b/src/ert/__main__.py index 8e091217c25..93abca6b7fa 100755 --- a/src/ert/__main__.py +++ b/src/ert/__main__.py @@ -387,20 +387,18 @@ def get_ert_parser(parser: Optional[ArgumentParser] = None) -> ArgumentParser: alternative_option="--current-ensemble", dest="current_ensemble", default="default", - help="Deprecated: This argument is deprecated and will be " - "removed in future versions. Use --current-ensemble instead.", + help="Deprecated: This argument is deprecated and has no effect.", ) ensemble_smoother_parser.add_argument( "--current-ensemble", type=valid_name, default="default", - help="Name of the ensemble where the results for the experiment " - "using the prior parameters will be stored.", + help="This argument is deprecated and has no effect.", ) ensemble_smoother_parser.add_argument( "--target-case", - type=valid_name, - default="posterior", + type=valid_name_format, + default="iter-%d", action=DeprecatedAction, alternative_option="--target-ensemble", dest="target_ensemble", @@ -409,8 +407,8 @@ def get_ert_parser(parser: Optional[ArgumentParser] = None) -> ArgumentParser: ) ensemble_smoother_parser.add_argument( "--target-ensemble", - type=valid_name, - default="posterior", + type=valid_name_format, + default="iter_%d", dest="target_ensemble", help="Name of the ensemble where the results for the " "updated parameters will be stored.", diff --git a/src/ert/cli/main.py b/src/ert/cli/main.py index 4317a9e67bc..b1f4aa32735 100644 --- a/src/ert/cli/main.py +++ b/src/ert/cli/main.py @@ -94,7 +94,7 @@ def run_cli(args: Namespace, plugin_manager: Optional[ErtPluginManager] = None) status_queue, ) except ValueError as e: - raise ErtCliError(e) from e + raise ErtCliError(f"{args.mode} was not valid, failed with: {e}") from e if args.port_range is None and model.queue_system == QueueSystem.LOCAL: args.port_range = range(49152, 51819) diff --git a/src/ert/cli/model_factory.py b/src/ert/cli/model_factory.py index 7a55141eb9d..c8718c5e272 100644 --- a/src/ert/cli/model_factory.py +++ b/src/ert/cli/model_factory.py @@ -240,11 +240,13 @@ def _setup_multiple_data_assimilation( weights=args.weights, restart_run=restart_run, prior_ensemble_id=prior_ensemble, + starting_iteration=storage.get_ensemble(prior_ensemble).iteration + 1 + if restart_run + else 0, minimum_required_realizations=config.analysis_config.minimum_required_realizations, ensemble_size=config.model_config.num_realizations, stop_long_running=config.analysis_config.stop_long_running, experiment_name=args.experiment_name, - starting_iteration=args.starting_iteration, ), config, storage, @@ -269,7 +271,7 @@ def _setup_iterative_ensemble_smoother( args, config.model_config.num_realizations ).tolist(), target_ensemble=_iterative_ensemble_format(config, args), - num_iterations=_num_iterations(config, args), + number_of_iterations=_num_iterations(config, args), minimum_required_realizations=config.analysis_config.minimum_required_realizations, ensemble_size=config.model_config.num_realizations, num_retries_per_iter=config.analysis_config.num_retries_per_iter, diff --git a/src/ert/gui/simulation/multiple_data_assimilation_panel.py b/src/ert/gui/simulation/multiple_data_assimilation_panel.py index a6c35b5c587..8b7ce6fe4e2 100644 --- a/src/ert/gui/simulation/multiple_data_assimilation_panel.py +++ b/src/ert/gui/simulation/multiple_data_assimilation_panel.py @@ -36,7 +36,6 @@ class Arguments: restart_run: bool prior_ensemble_id: str # UUID not serializable in json experiment_name: str - starting_iteration: int class MultipleDataAssimilationPanel(ExperimentConfigPanel): @@ -166,9 +165,9 @@ def updateVisualizationOfNormalizedWeights() -> None: normalized_weights_model.setValue( ", ".join(f"{x:.2f}" for x in normalized_weights) ) + self.weights_valid = True except ValueError: normalized_weights_model.setValue("The weights are invalid!") - self.weights_valid = True else: normalized_weights_model.setValue("The weights are invalid!") @@ -203,11 +202,6 @@ def get_experiment_arguments(self) -> Arguments: if self._experiment_name_field.text() else self._experiment_name_field.placeholderText() ), - starting_iteration=( - str(self._ensemble_selector.selected_ensemble.iteration + 1) - if self._restart_box.isChecked() - else 0 - ), ) def setWeights(self, weights: Any) -> None: diff --git a/src/ert/run_models/base_run_model.py b/src/ert/run_models/base_run_model.py index 4eeb396a64e..bb16a939cc6 100644 --- a/src/ert/run_models/base_run_model.py +++ b/src/ert/run_models/base_run_model.py @@ -164,7 +164,9 @@ def __init__( self._exception: Optional[Exception] = None self._error_messages: MutableSequence[str] = [] self._queue_config: QueueConfig = queue_config - self._initial_realizations_mask: List[bool] = [] + self._initial_realizations_mask: List[bool] = copy.copy( + simulation_arguments.active_realizations + ) self._completed_realizations_mask: List[bool] = [] self.support_restart: bool = True self.ert_config = config @@ -176,9 +178,10 @@ def __init__( # mapping from iteration number to ensemble id self._iter_map: Dict[int, str] = {} self._context_env_keys: List[str] = [] - self.random_seed: int = _seed_sequence(self._simulation_arguments.random_seed) + self.random_seed: int = _seed_sequence(simulation_arguments.random_seed) self.rng = np.random.default_rng(self.random_seed) self.substitution_list = config.substitution_list + self.run_paths = Runpaths( jobname_format=config.model_config.jobname_format_string, runpath_format=config.model_config.runpath_format_string, diff --git a/src/ert/run_models/ensemble_smoother.py b/src/ert/run_models/ensemble_smoother.py index a583315b346..62c1367e572 100644 --- a/src/ert/run_models/ensemble_smoother.py +++ b/src/ert/run_models/ensemble_smoother.py @@ -61,7 +61,7 @@ def run_experiment( self, evaluator_server_config: EvaluatorServerConfig ) -> RunContext: self.checkHaveSufficientRealizations( - self._simulation_arguments.active_realizations.count(True), + self.active_realizations.count(True), self.minimum_required_realizations, ) @@ -87,9 +87,7 @@ def run_experiment( prior_context = RunContext( ensemble=prior, runpaths=self.run_paths, - initial_mask=np.array( - self._simulation_arguments.active_realizations, dtype=bool - ), + initial_mask=np.array(self.active_realizations, dtype=bool), iteration=0, ) diff --git a/src/ert/run_models/evaluate_ensemble.py b/src/ert/run_models/evaluate_ensemble.py index 20980a13a8d..6ae4356f95b 100644 --- a/src/ert/run_models/evaluate_ensemble.py +++ b/src/ert/run_models/evaluate_ensemble.py @@ -65,9 +65,7 @@ def run_experiment( prior_context = RunContext( ensemble=ensemble, runpaths=self.run_paths, - initial_mask=np.array( - self._simulation_arguments.active_realizations, dtype=bool - ), + initial_mask=np.array(self.active_realizations, dtype=bool), iteration=ensemble.iteration, ) diff --git a/src/ert/run_models/multiple_data_assimilation.py b/src/ert/run_models/multiple_data_assimilation.py index 25de45770b6..69115dc5c13 100644 --- a/src/ert/run_models/multiple_data_assimilation.py +++ b/src/ert/run_models/multiple_data_assimilation.py @@ -83,17 +83,15 @@ def run_experiment( prior_context = RunContext( ensemble=prior, runpaths=self.run_paths, - initial_mask=np.array( - self._simulation_arguments.active_realizations, dtype=bool - ), + initial_mask=np.array(self.active_realizations, dtype=bool), iteration=prior.iteration, ) self.prev_successful_realizations = ( prior.get_realization_mask_without_failure().sum() ) - if self.starting_iteration != prior.iteration + 1: + if self.start_iteration != prior.iteration + 1: raise ValueError( - f"Experiment misconfigured, got starting iteration: {self.starting_iteration}," + f"Experiment misconfigured, got starting iteration: {self.start_iteration}," f"restart iteration = {prior.iteration + 1}" ) except (KeyError, ValueError) as err: @@ -242,7 +240,8 @@ def parseWeights(weights: str) -> List[float]: result.append(f) except ValueError as e: raise ValueError(f"Warning: cannot parse weight {element}") from e - + if not result: + raise ValueError(f"Invalid weights: {weights}") weights = [weight for weight in result if abs(weight) != 0.0] length = sum(1.0 / x for x in weights) diff --git a/src/ert/run_models/run_arguments.py b/src/ert/run_models/run_arguments.py index 9ce29664c3a..b0e536c611c 100644 --- a/src/ert/run_models/run_arguments.py +++ b/src/ert/run_models/run_arguments.py @@ -1,5 +1,5 @@ from dataclasses import dataclass -from typing import List, Optional, Union +from typing import List, Optional @dataclass @@ -52,17 +52,6 @@ class ESMDARunArguments(SimulationArguments): @dataclass class SIESRunArguments(SimulationArguments): target_ensemble: str - num_iterations: int num_retries_per_iter: int - ensemble_type: str = "IES" number_of_iterations: int = 3 - - -RunArgumentsType = Union[ - SingleTestRunArguments, - EnsembleExperimentRunArguments, - EvaluateEnsembleRunArguments, - ESRunArguments, - ESMDARunArguments, - SIESRunArguments, -] + ensemble_type: str = "IES" diff --git a/src/ert/storage/local_experiment.py b/src/ert/storage/local_experiment.py index 2d59b0d8d28..74aa224f296 100644 --- a/src/ert/storage/local_experiment.py +++ b/src/ert/storage/local_experiment.py @@ -28,7 +28,7 @@ if TYPE_CHECKING: from ert.config.parameter_config import ParameterConfig from ert.run_models.run_arguments import ( - RunArgumentsType, + SimulationArguments, ) from ert.storage.local_ensemble import LocalEnsemble from ert.storage.local_storage import LocalStorage @@ -100,7 +100,7 @@ def create( parameters: Optional[List[ParameterConfig]] = None, responses: Optional[List[ResponseConfig]] = None, observations: Optional[Dict[str, xr.Dataset]] = None, - simulation_arguments: Optional[RunArgumentsType] = None, + simulation_arguments: Optional[SimulationArguments] = None, name: Optional[str] = None, ) -> LocalExperiment: """ @@ -120,7 +120,7 @@ def create( List of response configurations. observations : dict of str: xr.Dataset, optional Observations dictionary. - simulation_arguments : RunArgumentsType, optional + simulation_arguments : SimulationArguments, optional Simulation arguments for the experiment. name : str, optional Experiment name. Defaults to current date if None. diff --git a/src/ert/storage/local_storage.py b/src/ert/storage/local_storage.py index 278dce5fed0..95882a5c68f 100644 --- a/src/ert/storage/local_storage.py +++ b/src/ert/storage/local_storage.py @@ -37,7 +37,7 @@ if TYPE_CHECKING: from ert.config import ParameterConfig, ResponseConfig - from ert.run_models.run_arguments import RunArgumentsType + from ert.run_models.run_arguments import SimulationArguments logger = logging.getLogger(__name__) @@ -147,7 +147,7 @@ def get_experiment(self, uuid: UUID) -> LocalExperiment: return self._experiments[uuid] - def get_ensemble(self, uuid: UUID) -> LocalEnsemble: + def get_ensemble(self, uuid: Union[UUID, str]) -> LocalEnsemble: """ Retrieves an ensemble by UUID. @@ -160,7 +160,8 @@ def get_ensemble(self, uuid: UUID) -> LocalEnsemble: local_ensemble : LocalEnsemble The ensemble associated with the given UUID. """ - + if isinstance(uuid, str): + uuid = UUID(uuid) return self._ensembles[uuid] def get_ensemble_by_name(self, name: str) -> LocalEnsemble: @@ -297,7 +298,7 @@ def create_experiment( parameters: Optional[List[ParameterConfig]] = None, responses: Optional[List[ResponseConfig]] = None, observations: Optional[Dict[str, xr.Dataset]] = None, - simulation_arguments: Optional[RunArgumentsType] = None, + simulation_arguments: Optional[SimulationArguments] = None, name: Optional[str] = None, ) -> LocalExperiment: """ @@ -311,7 +312,7 @@ def create_experiment( The responses for the experiment. observations : dict of str to Dataset, optional The observations for the experiment. - simulation_arguments : RunArgumentsType, optional + simulation_arguments : SimulationArguments, optional The simulation arguments for the experiment. name : str, optional The name of the experiment. diff --git a/tests/integration_tests/analysis/test_adaptive_localization.py b/tests/integration_tests/analysis/test_adaptive_localization.py index 591f7a254e1..5697711db30 100644 --- a/tests/integration_tests/analysis/test_adaptive_localization.py +++ b/tests/integration_tests/analysis/test_adaptive_localization.py @@ -12,16 +12,9 @@ def run_cli_ES_with_case(poly_config): - config_name = poly_config.split(".")[0] - prior_sample_name = "prior_sample" + "_" + config_name - posterior_sample_name = "posterior_sample" + "_" + config_name run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - prior_sample_name, - "--target-case", - posterior_sample_name, "--realizations", "1-50", poly_config, @@ -30,8 +23,8 @@ def run_cli_ES_with_case(poly_config): ) storage_path = ErtConfig.from_file(poly_config).ens_path with open_storage(storage_path) as storage: - prior_ensemble = storage.get_ensemble_by_name(prior_sample_name) - posterior_ensemble = storage.get_ensemble_by_name(posterior_sample_name) + prior_ensemble = storage.get_ensemble_by_name("iter-0") + posterior_ensemble = storage.get_ensemble_by_name("iter-1") return prior_ensemble, posterior_ensemble diff --git a/tests/integration_tests/analysis/test_es_update.py b/tests/integration_tests/analysis/test_es_update.py index 1caad413b07..c0153c19cb3 100644 --- a/tests/integration_tests/analysis/test_es_update.py +++ b/tests/integration_tests/analysis/test_es_update.py @@ -66,19 +66,15 @@ def test_that_posterior_has_lower_variance_than_prior(): run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - "default", - "--target-case", - "target", "--realizations", "1-50", "poly.ert", ) facade = LibresFacade.from_config_file("poly.ert") with open_storage(facade.enspath) as storage: - prior_ensemble = storage.get_ensemble_by_name("default") + prior_ensemble = storage.get_ensemble_by_name("iter-0") df_default = prior_ensemble.load_all_gen_kw_data() - posterior_ensemble = storage.get_ensemble_by_name("target") + posterior_ensemble = storage.get_ensemble_by_name("iter-1") df_target = posterior_ensemble.load_all_gen_kw_data() # The std for the ensemble should decrease @@ -142,16 +138,14 @@ def sample_prior(nx, ny): ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", "snake_oil_surface.ert", - "--target-case", - "es_udpate", ) ert_config = ErtConfig.from_file("snake_oil_surface.ert") storage = open_storage(ert_config.ens_path) - ens_prior = storage.get_ensemble_by_name("default") - ens_posterior = storage.get_ensemble_by_name("es_udpate") + ens_prior = storage.get_ensemble_by_name("iter-0") + ens_posterior = storage.get_ensemble_by_name("iter-1") # Check that surfaces defined in INIT_FILES are not changed by ERT surf_prior = ens_prior.load_parameters("TOP", list(range(ensemble_size)))["values"] @@ -182,15 +176,13 @@ def test_update_multiple_param(): ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", "snake_oil.ert", - "--target-case", - "posterior", ) ert_config = ErtConfig.from_file("snake_oil.ert") storage = open_storage(ert_config.ens_path) - prior_ensemble = storage.get_ensemble_by_name("default") - posterior_ensemble = storage.get_ensemble_by_name("posterior") + prior_ensemble = storage.get_ensemble_by_name("iter-0") + posterior_ensemble = storage.get_ensemble_by_name("iter-1") prior_array = _all_parameters(prior_ensemble, list(range(10))) posterior_array = _all_parameters(posterior_ensemble, list(range(10))) @@ -480,15 +472,13 @@ def _evaluate(coeffs, x): ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", "poly.ert", - "--target-case", - "posterior", ) ert_config = ErtConfig.from_file("poly.ert") with open_storage(ert_config.ens_path) as storage: - prior = storage.get_ensemble_by_name("default") - posterior = storage.get_ensemble_by_name("posterior") + prior = storage.get_ensemble_by_name("iter-0") + posterior = storage.get_ensemble_by_name("iter-1") assert all( posterior.get_ensemble_state()[idx] diff --git a/tests/integration_tests/status/test_tracking_integration.py b/tests/integration_tests/status/test_tracking_integration.py index b3c7e75ca4a..13b14a1d5fc 100644 --- a/tests/integration_tests/status/test_tracking_integration.py +++ b/tests/integration_tests/status/test_tracking_integration.py @@ -111,8 +111,6 @@ def check_expression(original, path_expression, expected, msg_start): "", [ ENSEMBLE_SMOOTHER_MODE, - "--target-case", - "poly_runpath_file", "--realizations", "0,1", "poly.ert", @@ -128,8 +126,6 @@ def check_expression(original, path_expression, expected, msg_start): ' import os\n if os.getcwd().split("/")[-2].split("-")[1] == "0": sys.exit(1)', # noqa 501 [ ENSEMBLE_SMOOTHER_MODE, - "--target-case", - "poly_runpath_file", "--realizations", "0,1", "poly.ert", diff --git a/tests/integration_tests/storage/test_field_parameter.py b/tests/integration_tests/storage/test_field_parameter.py index 129aa913425..46afa670676 100644 --- a/tests/integration_tests/storage/test_field_parameter.py +++ b/tests/integration_tests/storage/test_field_parameter.py @@ -106,16 +106,12 @@ def test_field_param_update(tmpdir): run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - "prior", - "--target-case", - "smoother_update", "config.ert", ) config = ErtConfig.from_file("config.ert") with open_storage(config.ens_path, mode="w") as storage: - prior = storage.get_ensemble_by_name("prior") - posterior = storage.get_ensemble_by_name("smoother_update") + prior = storage.get_ensemble_by_name("iter-0") + posterior = storage.get_ensemble_by_name("iter-1") prior_result = prior.load_parameters("MY_PARAM", list(range(5)))["values"] assert len(prior_result.x) == NCOL @@ -237,16 +233,12 @@ def test_parameter_update_with_inactive_cells_xtgeo_grdecl(tmpdir): run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - "prior", - "--target-case", - "smoother_update", "config.ert", ) config = ErtConfig.from_file("config.ert") with open_storage(config.ens_path) as storage: - prior = storage.get_ensemble_by_name("prior") - posterior = storage.get_ensemble_by_name("smoother_update") + prior = storage.get_ensemble_by_name("iter-0") + posterior = storage.get_ensemble_by_name("iter-1") prior_result = prior.load_parameters("MY_PARAM", list(range(realizations)))[ "values" diff --git a/tests/integration_tests/storage/test_parameter_sample_types.py b/tests/integration_tests/storage/test_parameter_sample_types.py index 523babda1de..ccc02015c29 100644 --- a/tests/integration_tests/storage/test_parameter_sample_types.py +++ b/tests/integration_tests/storage/test_parameter_sample_types.py @@ -120,15 +120,11 @@ def test_surface_param_update(tmpdir): run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - "prior", - "--target-case", - "smoother_update", "config.ert", ) with open_storage(tmpdir / "storage") as storage: - prior = storage.get_ensemble_by_name("prior") - posterior = storage.get_ensemble_by_name("smoother_update") + prior = storage.get_ensemble_by_name("iter-0") + posterior = storage.get_ensemble_by_name("iter-1") prior_param = ( prior.load_parameters("MY_PARAM", list(range(5)))["values"] .values.reshape(5, 2 * 3) @@ -271,9 +267,5 @@ def run_poly(): run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - "prior", - "--target-case", - "smoother_update", "config.ert", ) diff --git a/tests/integration_tests/test_cli.py b/tests/integration_tests/test_cli.py index 547cdcd2bf1..c9d777ca4e7 100644 --- a/tests/integration_tests/test_cli.py +++ b/tests/integration_tests/test_cli.py @@ -129,7 +129,7 @@ def test_that_the_cli_raises_exceptions_when_parameters_are_missing(mode): "--disable-monitor", "poly-no-gen-kw.ert", "--target-case", - "testcase" if mode is ENSEMBLE_SMOOTHER_MODE else "testcase-%d", + "testcase-%d", ) @@ -137,10 +137,7 @@ def test_that_the_cli_raises_exceptions_when_parameters_are_missing(mode): def test_that_the_cli_raises_exceptions_when_no_weight_provided_for_es_mda(): with pytest.raises( ErtCliError, - match=( - "Operation halted: ES-MDA requires weights to proceed. " - "Please provide appropriate weights and try again." - ), + match="Invalid weights: 0", ): run_cli( ES_MDA_MODE, @@ -256,7 +253,7 @@ def test_that_the_model_raises_exception_if_active_less_than_minimum_realization "--realizations", "0-19", "--target-case", - "testcase" if mode is ENSEMBLE_SMOOTHER_MODE else "testcase-%d", + "testcase-%d", ) @@ -606,7 +603,7 @@ def test_ensemble_evaluator(): ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", "--target-case", - "poly_runpath_file", + "poly_runpath_file_%d", "--realizations", "1,2,4,8,16,32,64", "poly.ert", @@ -650,7 +647,9 @@ def test_es_mda(snapshot): @pytest.mark.parametrize( "mode, target", [ - pytest.param(ENSEMBLE_SMOOTHER_MODE, "target", id=f"{ENSEMBLE_SMOOTHER_MODE}"), + pytest.param( + ENSEMBLE_SMOOTHER_MODE, "target_%d", id=f"{ENSEMBLE_SMOOTHER_MODE}" + ), pytest.param( ITERATIVE_ENSEMBLE_SMOOTHER_MODE, "iter-%d", @@ -680,8 +679,6 @@ def test_ensemble_evaluator_disable_monitoring(): run_cli( ENSEMBLE_SMOOTHER_MODE, "--disable-monitoring", - "--target-case", - "poly_runpath_file", "--realizations", "1,2,4,8,16,32,64", "poly.ert", @@ -869,13 +866,13 @@ def test_exclude_parameter_from_update(): ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", "--target-case", - "iter-1", + "iter-%d", "--realizations", "0-5", "poly.ert", ) with open_storage("storage", "r") as storage: - prior = storage.get_ensemble_by_name("default") + prior = storage.get_ensemble_by_name("iter-0") posterior = storage.get_ensemble_by_name("iter-1") assert prior.load_parameters( "ANOTHER_KW", tuple(range(5)) diff --git a/tests/unit_tests/all/test_main.py b/tests/unit_tests/all/test_main.py index 57cb45a5961..3641d85ac6c 100644 --- a/tests/unit_tests/all/test_main.py +++ b/tests/unit_tests/all/test_main.py @@ -90,27 +90,20 @@ def test_argparse_exec_ensemble_experiment_faulty_realizations(): ) -def test_argparse_exec_ensemble_smoother_valid_case(): - parsed = ert_parser( - None, - [ENSEMBLE_SMOOTHER_MODE, "--target-case", "some_case", "path/to/config.ert"], - ) - assert parsed.mode == ENSEMBLE_SMOOTHER_MODE - assert parsed.target_ensemble == "some_case" - assert parsed.func.__name__ == "run_cli" - - -def test_argparse_exec_iterative_ensemble_smoother_valid_case(): +@pytest.mark.parametrize( + "mode", [ITERATIVE_ENSEMBLE_SMOOTHER_MODE, ENSEMBLE_SMOOTHER_MODE] +) +def test_argparse_exec_smoother_valid_case(mode): parsed = ert_parser( None, [ - ITERATIVE_ENSEMBLE_SMOOTHER_MODE, + mode, "--target-case", "some_case_%d", "path/to/config.ert", ], ) - assert parsed.mode == ITERATIVE_ENSEMBLE_SMOOTHER_MODE + assert parsed.mode == mode assert parsed.target_ensemble == "some_case_%d" assert parsed.func.__name__ == "run_cli" @@ -159,23 +152,6 @@ def test_argparse_exec_workflow(): assert parsed.func.__name__ == "run_cli" -def test_argparse_exec_ensemble_smoother_current_ensemble(): - parsed = ert_parser( - None, - [ - ENSEMBLE_SMOOTHER_MODE, - "--current-case", - "test_case", - "--target-case", - "test_case_smoother", - "path/to/config.ert", - ], - ) - assert parsed.mode == ENSEMBLE_SMOOTHER_MODE - assert parsed.current_ensemble == "test_case" - assert parsed.func.__name__ == "run_cli" - - def test_argparse_exec_iterative_ensemble_smoother_current_ensemble(): parsed = ert_parser( None, diff --git a/tests/unit_tests/cli/test_model_factory.py b/tests/unit_tests/cli/test_model_factory.py index 01c42ab44fa..fa938d7b49a 100644 --- a/tests/unit_tests/cli/test_model_factory.py +++ b/tests/unit_tests/cli/test_model_factory.py @@ -60,8 +60,6 @@ def test_setup_single_test_run(poly_case, storage): MagicMock(), ) assert isinstance(model, SingleTestRun) - assert model.simulation_arguments.ensemble_id == "current-ensemble" - assert model.simulation_arguments.target_ensemble is None assert model._storage == storage assert model.ert_config == poly_case @@ -79,8 +77,6 @@ def test_setup_single_test_run_with_ensemble(poly_case, storage): MagicMock(), ) assert isinstance(model, SingleTestRun) - assert model.simulation_arguments.ensemble_id == "current-ensemble" - assert model.simulation_arguments.target_ensemble is None assert model._storage == storage assert model.ert_config == poly_case @@ -117,10 +113,8 @@ def test_setup_ensemble_smoother(poly_case, storage): poly_case, storage, args, MagicMock(), MagicMock() ) assert isinstance(model, EnsembleSmoother) - assert model.simulation_arguments.current_ensemble == "default" - assert model.simulation_arguments.target_ensemble == "test_case" assert ( - model.simulation_arguments.active_realizations + model.active_realizations == [True] * 5 + [False] * 2 + [True] * 2 + [False] * 91 ) @@ -133,6 +127,7 @@ def test_setup_multiple_data_assimilation(poly_case, storage): restart_run=False, prior_ensemble_id="b272fe09-83ac-4744-b667-9a0a5415420b", experiment_name=None, + starting_iteration=0, ) model = model_factory._setup_multiple_data_assimilation( @@ -141,7 +136,7 @@ def test_setup_multiple_data_assimilation(poly_case, storage): assert isinstance(model, MultipleDataAssimilation) assert model.simulation_arguments.weights == "6,4,2" assert ( - model.simulation_arguments.active_realizations + model.active_realizations == [True] * 5 + [False] * 3 + [True] * 1 + [False] * 91 ) assert model.simulation_arguments.target_ensemble == "test_case_%d" @@ -155,7 +150,6 @@ def test_setup_multiple_data_assimilation(poly_case, storage): def test_setup_iterative_ensemble_smoother(poly_case, storage): args = Namespace( realizations="0-4,7,8", - current_ensemble="default", target_ensemble="test_case_%d", num_iterations="10", experiment_name=None, @@ -167,8 +161,8 @@ def test_setup_iterative_ensemble_smoother(poly_case, storage): assert isinstance(model, IteratedEnsembleSmoother) assert model.simulation_arguments.target_ensemble == "test_case_%d" assert ( - model.simulation_arguments.active_realizations + model.active_realizations == [True] * 5 + [False] * 2 + [True] * 2 + [False] * 91 ) - assert model.simulation_arguments.num_iterations == 10 + assert model.simulation_arguments.number_of_iterations == 10 assert poly_case.analysis_config.num_iterations == 10 diff --git a/tests/unit_tests/cli/test_model_hook_order.py b/tests/unit_tests/cli/test_model_hook_order.py index 7a528d47d52..66295e0c428 100644 --- a/tests/unit_tests/cli/test_model_hook_order.py +++ b/tests/unit_tests/cli/test_model_hook_order.py @@ -94,6 +94,7 @@ def test_hook_call_order_es_mda(monkeypatch): ensemble_size=1, stop_long_running=False, experiment_name="no-name", + starting_iteration=0, ) monkeypatch.setattr(multiple_data_assimilation, "sample_prior", MagicMock()) monkeypatch.setattr(multiple_data_assimilation, "smoother_update", MagicMock()) @@ -138,7 +139,7 @@ def test_hook_call_order_iterative_ensemble_smoother(monkeypatch): random_seed=None, active_realizations=[True], target_ensemble="target_%d", - num_iterations=1, + number_of_iterations=1, num_retries_per_iter=1, minimum_required_realizations=0, ensemble_size=1, diff --git a/tests/unit_tests/cli/test_run_context.py b/tests/unit_tests/cli/test_run_context.py index 252c52b9001..d0ab81384fc 100644 --- a/tests/unit_tests/cli/test_run_context.py +++ b/tests/unit_tests/cli/test_run_context.py @@ -26,6 +26,7 @@ def test_that_all_iterations_gets_correct_name_and_iteration_number( ensemble_size=1, stop_long_running=True, experiment_name="no-name", + starting_iteration=0, ) ens_mock = MagicMock() ens_mock.iteration = 0 diff --git a/tests/unit_tests/dark_storage/conftest.py b/tests/unit_tests/dark_storage/conftest.py index 88c617ea62e..79a2e583530 100644 --- a/tests/unit_tests/dark_storage/conftest.py +++ b/tests/unit_tests/dark_storage/conftest.py @@ -33,10 +33,6 @@ def poly_example_tmp_dir_shared( [ ENSEMBLE_SMOOTHER_MODE, "--disable-monitor", - "--current-case", - "alpha", - "--target-case", - "beta", "--realizations", "1,2,4", "poly.ert", diff --git a/tests/unit_tests/dark_storage/test_http_endpoints.py b/tests/unit_tests/dark_storage/test_http_endpoints.py index 91e9e3f4027..6610413e712 100644 --- a/tests/unit_tests/dark_storage/test_http_endpoints.py +++ b/tests/unit_tests/dark_storage/test_http_endpoints.py @@ -28,7 +28,7 @@ def test_get_ensemble(poly_example_tmp_dir, dark_storage_client): ensemble_json = resp.json() assert ensemble_json["experiment_id"] == experiment_json[0]["id"] - assert ensemble_json["userdata"]["name"] in ("alpha", "beta") + assert ensemble_json["userdata"]["name"] in ("iter-0", "iter-1") assert ensemble_json["userdata"]["experiment_name"] == experiment_json[0]["name"] @@ -45,7 +45,7 @@ def test_get_experiment_ensemble(poly_example_tmp_dir, dark_storage_client): assert len(ensembles_json) == 2 assert ensembles_json[0]["experiment_id"] == experiment_json[0]["id"] - assert ensembles_json[0]["userdata"]["name"] in ("alpha", "beta") + assert ensembles_json[0]["userdata"]["name"] in ("iter-0", "iter-1") def test_get_responses_with_observations(poly_example_tmp_dir, dark_storage_client): @@ -72,13 +72,13 @@ def test_get_response(poly_example_tmp_dir, dark_storage_client): # Make sure the order is correct resp: Response = dark_storage_client.get(f"/ensembles/{ensemble_id1}") - if resp.json()["userdata"]["name"] == "beta": - # First ensemble is 'beta', switch it so it is 'alpha' + if resp.json()["userdata"]["name"] == "iter-1": + # First ensemble is 'iter-1', switch it so it is 'iter-0' ensemble_id1, ensemble_id2 = ensemble_id2, ensemble_id1 resp: Response = dark_storage_client.get(f"/ensembles/{ensemble_id1}") ensemble_json = resp.json() - assert ensemble_json["userdata"]["name"] == "alpha", ( + assert ensemble_json["userdata"]["name"] == "iter-0", ( f"\nexperiment_json: {json.dumps(experiment_json, indent=1)} \n\n" f"ensemble_json: {json.dumps(ensemble_json, indent=1)}" ) @@ -86,7 +86,7 @@ def test_get_response(poly_example_tmp_dir, dark_storage_client): resp: Response = dark_storage_client.get(f"/ensembles/{ensemble_id2}") ensemble_json2 = resp.json() - assert ensemble_json2["userdata"]["name"] == "beta", ( + assert ensemble_json2["userdata"]["name"] == "iter-1", ( f"\nexperiment_json: {json.dumps(experiment_json, indent=1)} \n\n" f"ensemble_json2: {json.dumps(ensemble_json2, indent=1)}" )