ert 16.0.9__py3-none-any.whl → 19.0.0rc2__py3-none-any.whl

ert/run_models/everest_run_model.py

@@ -10,43 +10,45 @@ import os
 import queue
 import shutil
 import traceback
+import warnings
 from collections import defaultdict
 from collections.abc import Callable, Iterator, MutableSequence
 from enum import IntEnum, auto
 from functools import cached_property
 from pathlib import Path
 from types import TracebackType
-from typing import TYPE_CHECKING, Any, Protocol
+from typing import TYPE_CHECKING, Any, Protocol, cast
 
 import numpy as np
 from numpy.typing import NDArray
 from pydantic import PrivateAttr, ValidationError
 from ropt.enums import ExitCode as RoptExitCode
 from ropt.evaluator import EvaluatorContext, EvaluatorResult
-from ropt.plan import BasicOptimizer
 from ropt.results import FunctionResults, Results
 from ropt.transforms import OptModelTransforms
+from ropt.workflow import BasicOptimizer
 from typing_extensions import TypedDict
 
 from ert.config import (
     EverestConstraintsConfig,
+    EverestControl,
     EverestObjectivesConfig,
     GenDataConfig,
+    HookRuntime,
+    KnownQueueOptionsAdapter,
     ParameterConfig,
     QueueConfig,
     ResponseConfig,
     SummaryConfig,
+    WorkflowJob,
 )
 from ert.config.ert_config import (
     create_and_hook_workflows,
-    read_templates,
     uppercase_subkeys_and_stringify_subvalues,
-    workflow_jobs_from_dict,
-)
-from ert.config.model_config import (
-    DEFAULT_ECLBASE_FORMAT,
 )
+from ert.config.model_config import DEFAULT_ECLBASE_FORMAT
 from ert.config.model_config import ModelConfig as ErtModelConfig
+from ert.config.parsing import ConfigWarning
 from ert.ensemble_evaluator import EndEvent, EvaluatorServerConfig
 from ert.plugins import ErtRuntimePlugins
 from ert.runpaths import Runpaths
@@ -55,31 +57,23 @@ from everest.config import (
     EverestConfig,
     InputConstraintConfig,
     ModelConfig,
-    ObjectiveFunctionConfig,
     OptimizationConfig,
-    OutputConstraintConfig,
 )
-from everest.config.forward_model_config import SummaryResults
+from everest.config.forward_model_config import ForwardModelStepConfig, SummaryResults
 from everest.everest_storage import EverestStorage
 from everest.optimizer.everest2ropt import everest2ropt
 from everest.optimizer.opt_model_transforms import (
     EverestOptModelTransforms,
     get_optimization_domain_transforms,
 )
-from everest.simulator.everest_to_ert import (
-    _get_workflow_files,
-    everest_to_ert_config_dict,
-    extract_summary_keys,
-    get_substitutions,
-    get_workflow_jobs,
-)
-from everest.strings import EVEREST, STORAGE_DIR
+from everest.strings import EVEREST
 
 from ..run_arg import RunArg, create_run_arguments
+from ..storage import ExperimentState, ExperimentStatus
 from ..storage.local_ensemble import EverestRealizationInfo
 from ..substitutions import Substitutions
 from .event import EverestBatchResultEvent, EverestStatusEvent
-from .run_model import RunModel, StatusEvents
+from .run_model import RunModel, RunModelConfig, StatusEvents
 
 if TYPE_CHECKING:
     from ert.storage import Ensemble, Experiment
@@ -173,6 +167,17 @@ def _get_install_data_files(ever_config: EverestConfig) -> Iterator[tuple[Path,
             yield (data_storage / Path(target).name, data)
 
 
+def _get_workflow_files(ever_config: EverestConfig) -> dict[str, tuple[Path, str]]:
+    data_storage = (Path(ever_config.output_dir) / ".internal_data").resolve()
+    return {
+        trigger: (
+            data_storage / f"{trigger}.workflow",
+            "\n".join(getattr(ever_config.workflows, trigger, [])),
+        )
+        for trigger in ("pre_simulation", "post_simulation")
+    }
+
+
 def _get_internal_files(ever_config: EverestConfig) -> dict[Path, str]:
     return dict(
         [
@@ -187,30 +192,52 @@ def _get_internal_files(ever_config: EverestConfig) -> dict[Path, str]:
     )
 
 
-class EverestRunModel(RunModel):
+def _get_workflow_jobs(ever_config: EverestConfig) -> dict[str, WorkflowJob]:
+    workflow_jobs: dict[str, WorkflowJob] = {}
+    for job in ever_config.install_workflow_jobs or []:
+        workflow = job.to_ert_executable_workflow(ever_config.config_directory)
+        if workflow.name in workflow_jobs:
+            ConfigWarning.warn(
+                f"Duplicate workflow job with name {job.name!r}, "
+                f"overriding it with {job.executable!r}.",
+                job.name,
+            )
+        workflow_jobs[workflow.name] = workflow
+    return workflow_jobs
+
+
+def _get_workflows(
+    ever_config: EverestConfig,
+) -> tuple[list[tuple[str, HookRuntime]], list[tuple[str, str]]]:
+    trigger2res: dict[str, HookRuntime] = {
+        "pre_simulation": HookRuntime.PRE_SIMULATION,
+        "post_simulation": HookRuntime.POST_SIMULATION,
+    }
+    res_hooks: list[tuple[str, HookRuntime]] = []
+    res_workflows: list[tuple[str, str]] = []
+    for ever_trigger, (workflow_file, jobs) in _get_workflow_files(ever_config).items():
+        if jobs:
+            res_hooks.append((ever_trigger, trigger2res[ever_trigger]))
+            res_workflows.append((str(workflow_file), ever_trigger))
+    return res_hooks, res_workflows
+
+
+class EverestRunModelConfig(RunModelConfig):
     optimization_output_dir: str
     simulation_dir: str
 
     parameter_configuration: list[ParameterConfig]
     response_configuration: list[ResponseConfig]
-    ert_templates: list[tuple[str, str]]
-
-    controls: list[ControlConfig]
-
-    objective_functions: list[ObjectiveFunctionConfig]
-    objective_names: list[str]
 
     input_constraints: list[InputConstraintConfig]
-
-    output_constraints: list[OutputConstraintConfig]
-    constraint_names: list[str]
-
     optimization: OptimizationConfig
     model: ModelConfig
     keep_run_path: bool
     experiment_name: str
     target_ensemble: str
 
+
+class EverestRunModel(RunModel, EverestRunModelConfig):
     _exit_code: EverestExitCode | None = PrivateAttr(default=None)
     _experiment: Experiment | None = PrivateAttr(default=None)
     _eval_server_cfg: EvaluatorServerConfig | None = PrivateAttr(default=None)
@@ -238,13 +265,9 @@ class EverestRunModel(RunModel):
             everest_config.environment.random_seed,
         )
 
-        storage_dir = os.path.join(everest_config.output_dir, STORAGE_DIR)
-
         if status_queue is None:
             status_queue = queue.SimpleQueue()
 
-        config_dict = everest_to_ert_config_dict(everest_config)
-
         runpath_file: Path = Path(
             os.path.join(everest_config.output_dir, ".res_runpath_list")
         )
@@ -267,20 +290,11 @@ class EverestRunModel(RunModel):
 
         response_configs: list[ResponseConfig] = []
 
-        objective_names = [c.name for c in everest_config.objective_functions]
-        response_configs.append(
-            EverestObjectivesConfig(keys=objective_names, input_files=objective_names)
-        )
+        response_configs.append(everest_config.create_ert_objectives_config())
 
-        constraint_names = [c.name for c in everest_config.output_constraints]
-
-        if constraint_names:
-            response_configs.append(
-                EverestConstraintsConfig(
-                    keys=constraint_names,
-                    input_files=constraint_names,
-                )
-            )
+        constraints_config = everest_config.create_ert_output_constraints_config()
+        if constraints_config is not None:
+            response_configs.append(constraints_config)
 
         gen_data_keys = [
             fm.results.file_name
@@ -302,7 +316,7 @@ class EverestRunModel(RunModel):
             eclbase = summary_fm.results.file_name
             response_configs.append(
                 SummaryConfig(
-                    keys=extract_summary_keys(everest_config), input_files=[eclbase]
+                    keys=_extract_summary_keys(everest_config), input_files=[eclbase]
                 )
             )
         else:
@@ -315,7 +329,7 @@ class EverestRunModel(RunModel):
             runpath_format_string=str(
                 Path(everest_config.simulation_dir)
                 / "batch_<ITER>"
-                / "realization_<GEO_ID>"
+                / "realization_<REALIZATION_ID>"
                 / "<SIM_DIR>"
             ),
             eclbase_format_string=eclbase
@@ -323,34 +337,91 @@ class EverestRunModel(RunModel):
             else DEFAULT_ECLBASE_FORMAT,
         )
 
-        queue_config = QueueConfig.from_dict(
-            config_dict,
-            site_queue_options=runtime_plugins.queue_options
-            if runtime_plugins
-            else None,
+        simulator_config = everest_config.simulator
+        queue_options_from_everconfig: dict[str, Any] = (
+            {"name": "local"}
+            if simulator_config.queue_system is None
+            else (
+                simulator_config.queue_system.model_dump(exclude_unset=True)
+                | {
+                    "name": simulator_config.queue_system.name,
+                }
+            )
+        )
+
+        if simulator_config.max_memory is not None:
+            queue_options_from_everconfig["realization_memory"] = (
+                simulator_config.max_memory or 0
+            )
+
+        # Number of cores reserved on queue nodes (NUM_CPU)
+        if (num_fm_cpu := simulator_config.cores_per_node) is not None:
+            if (
+                simulator_config.queue_system is not None
+                and "num_cpu" not in simulator_config.queue_system.model_fields_set
+            ):
+                queue_options_from_everconfig["num_cpu"] = num_fm_cpu
+            else:
+                warnings.warn(
+                    "Ignoring cores_per_node as num_cpu was set",
+                    UserWarning,
+                    stacklevel=2,
+                )
+
+        # Only take into account site queue options
+        # if and only if they exist and are of same type as user
+        # specified queue system
+        site_queue_options_to_apply = (
+            runtime_plugins.queue_options.model_dump(exclude_unset=True)
+            if (
+                runtime_plugins is not None
+                and runtime_plugins.queue_options is not None
+                and runtime_plugins.queue_options.name
+                == queue_options_from_everconfig["name"]
+            )
+            else {}
         )
-        assert everest_config.simulator is not None
-        assert everest_config.simulator.queue_system is not None
-        queue_config.queue_options = everest_config.simulator.queue_system
-        queue_config.queue_system = everest_config.simulator.queue_system.name
-
-        substitutions = get_substitutions(
-            config_dict,
-            runpath_config,
-            runpath_file,
-            queue_config.queue_options.num_cpu,
+
+        queue_options_dict = site_queue_options_to_apply | queue_options_from_everconfig
+
+        queue_options = KnownQueueOptionsAdapter.validate_python(queue_options_dict)
+
+        if queue_options.project_code is None:
+            tags = {
+                fm_name.lower()
+                for fm_name in everest_config.forward_model_step_commands
+                if fm_name.split(" ")[0].upper()
+                in {"RMS", "FLOW", "ECLIPSE100", "ECLIPSE300"}
+            }
+            if tags:
+                queue_options.project_code = "+".join(tags)
+
+        queue_config = QueueConfig(
+            max_submit=simulator_config.resubmit_limit + 1,
+            queue_system=queue_options.name,
+            queue_options=queue_options,
+            stop_long_running=False,
+            max_runtime=simulator_config.max_runtime,
         )
-        ert_templates = read_templates(config_dict)
+
+        substitutions = {
+            "<RUNPATH_FILE>": str(runpath_file),
+            "<RUNPATH>": runpath_config.runpath_format_string,
+            "<ECL_BASE>": runpath_config.eclbase_format_string,
+            "<ECLBASE>": runpath_config.eclbase_format_string,
+            "<NUM_CPU>": str(queue_config.queue_options.num_cpu),
+            "<CONFIG_PATH>": everest_config.config_directory,
+            "<CONFIG_FILE>": Path(everest_config.config_file).stem,
+        }
 
         for datafile, data in _get_internal_files(everest_config).items():
             datafile.parent.mkdir(exist_ok=True, parents=True)
             datafile.write_text(data, encoding="utf-8")
 
-        workflow_jobs = get_workflow_jobs(everest_config)
-        if deprecated_workflow_jobs := workflow_jobs_from_dict(config_dict):
-            workflow_jobs.update(deprecated_workflow_jobs)
+        workflow_jobs = _get_workflow_jobs(everest_config)
+        hooks, workflows = _get_workflows(everest_config)
         _, hooked_workflows = create_and_hook_workflows(
-            config_dict, workflow_jobs, substitutions
+            hooks, workflows, workflow_jobs, substitutions
         )
 
         install_job_fm_steps = {
@@ -425,21 +496,6 @@ class EverestRunModel(RunModel):
             for key, val in plugin_env_vars.items():
                 env_vars[key] = substituter.substitute(val)
 
-        for key, val in config_dict.get("SETENV", []):
-            if key in env_vars:
-                message = (
-                    f"Overriding environment variable: {key}, "
-                    f"old value: {env_vars[key]}, new value: {val}"
-                )
-
-                if key in plugin_env_vars:
-                    site_value = plugin_env_vars
-                    message += f", site configuration value: {site_value}"
-
-                logger.warning(message)
-
-            env_vars[key] = substituter.substitute(val)
-
         delete_run_path: bool = (
             everest_config.simulator is not None
             and everest_config.simulator.delete_run_path
@@ -452,10 +508,8 @@ class EverestRunModel(RunModel):
             simulation_dir=everest_config.simulation_dir,
             keep_run_path=not delete_run_path,
             objective_names=everest_config.objective_names,
-            constraint_names=everest_config.constraint_names,
             objective_functions=everest_config.objective_functions,
             input_constraints=everest_config.input_constraints,
-            output_constraints=everest_config.output_constraints,
             optimization=everest_config.optimization,
             model=everest_config.model,
             optimization_output_dir=everest_config.optimization_output_dir,
@@ -467,7 +521,6 @@ class EverestRunModel(RunModel):
             active_realizations=[],
             parameter_configuration=parameter_configs,
             response_configuration=response_configs,
-            ert_templates=ert_templates,
             user_config_file=config_file,
             env_vars=env_vars,
             env_pr_fm_step=env_pr_fm_step,
@@ -475,19 +528,29 @@ class EverestRunModel(RunModel):
             forward_model_steps=forward_model_steps,
             substitutions=substitutions,
             hooked_workflows=hooked_workflows,
-            storage_path=storage_dir,
+            storage_path=everest_config.storage_dir,
             queue_config=queue_config,
             status_queue=status_queue,
             optimization_callback=optimization_callback,
         )
 
+    @property
+    def _everest_control_configs(self) -> list[EverestControl]:
+        controls = [
+            c for c in self.parameter_configuration if c.type == "everest_parameters"
+        ]
+
+        # There will and must always be one EverestControl config for an
+        # Everest optimization.
+        return cast(list[EverestControl], controls)
+
     @cached_property
     def _transforms(self) -> EverestOptModelTransforms:
         return get_optimization_domain_transforms(
-            self.controls,
-            self.objective_functions,
+            self._everest_control_configs,
+            self.objectives_config,
             self.input_constraints,
-            self.output_constraints,
+            self.output_constraints_config,
             self.model,
             self.optimization.auto_scale,
         )
@@ -504,6 +567,14 @@ class EverestRunModel(RunModel):
     def exit_code(self) -> EverestExitCode | None:
         return self._exit_code
 
+    def cancel(self) -> None:
+        if self._experiment is not None:
+            self._experiment.status = ExperimentStatus(
+                message="Optimization aborted",
+                status=ExperimentState.stopped,
+            )
+        super().cancel()
+
     def __repr__(self) -> str:
         return f"EverestRunModel(config={self.user_config_file})"
 
@@ -542,7 +613,7 @@ class EverestRunModel(RunModel):
                             traceback=traceback_str,
                         )
                         if failed
-                        else "Experiment completed."
+                        else "Experiment completed"
                     ),
                 )
             )
@@ -573,6 +644,29 @@ class EverestRunModel(RunModel):
                 )
             )
 
+    @property
+    def output_constraints_config(self) -> EverestConstraintsConfig | None:
+        constraints_config = next(
+            (c for c in self.response_configuration if c.type == "everest_constraints"),
+            None,
+        )
+
+        if constraints_config is None:
+            return None
+
+        assert isinstance(constraints_config, EverestConstraintsConfig)
+        return constraints_config
+
+    @property
+    def objectives_config(self) -> EverestObjectivesConfig:
+        obj_config = next(
+            c for c in self.response_configuration if c.type == "everest_objectives"
+        )
+        # There will and must always be one objectives config for an
+        # Everest optimization.
+        assert isinstance(obj_config, EverestObjectivesConfig)
+        return obj_config
+
     def run_experiment(
         self,
         evaluator_server_config: EvaluatorServerConfig,
@@ -587,6 +681,10 @@ class EverestRunModel(RunModel):
             responses=self.response_configuration,
         )
 
+        self._experiment.status = ExperimentStatus(
+            message="Experiment started", status=ExperimentState.running
+        )
+
         # Initialize the ropt optimizer:
         optimizer, initial_guesses = self._create_optimizer()
 
@@ -595,18 +693,20 @@ class EverestRunModel(RunModel):
         )
 
         formatted_control_names = [
-            name for config in self.controls for name in config.formatted_control_names
+            name
+            for config in self._everest_control_configs
+            for name in config.input_keys
         ]
         self._ever_storage.init(
             formatted_control_names=formatted_control_names,
-            objective_functions=self.objective_functions,
-            output_constraints=self.output_constraints,
+            objective_functions=self.objectives_config,
+            output_constraints=self.output_constraints_config,
             realizations=self.model.realizations,
         )
         optimizer.set_results_callback(self._handle_optimizer_results)
 
         # Run the optimization:
-        optimizer_exit_code = optimizer.run(initial_guesses).exit_code
+        optimizer_exit_code = optimizer.run(initial_guesses)
 
         # Store some final results.
         self._ever_storage.on_optimization_finished()
@@ -617,22 +717,46 @@ class EverestRunModel(RunModel):
         ):
             self._ever_storage.export_everest_opt_results_to_csv()
 
+        experiment_status = None
         if self._exit_code is None:
             match optimizer_exit_code:
                 case RoptExitCode.MAX_FUNCTIONS_REACHED:
                     self._exit_code = EverestExitCode.MAX_FUNCTIONS_REACHED
+                    experiment_status = ExperimentStatus(
+                        message="Maximum number of function evaluations reached",
+                        status=ExperimentState.completed,
+                    )
                 case RoptExitCode.MAX_BATCHES_REACHED:
                     self._exit_code = EverestExitCode.MAX_BATCH_NUM_REACHED
+                    experiment_status = ExperimentStatus(
+                        message="Maximum number of batches reached",
+                        status=ExperimentState.completed,
+                    )
                 case RoptExitCode.USER_ABORT:
                     self._exit_code = EverestExitCode.USER_ABORT
+                    experiment_status = ExperimentStatus(
+                        message="Optimization aborted", status=ExperimentState.stopped
+                    )
                 case RoptExitCode.TOO_FEW_REALIZATIONS:
                     self._exit_code = (
                         EverestExitCode.TOO_FEW_REALIZATIONS
                         if self.get_number_of_successful_realizations() > 0
                         else EverestExitCode.ALL_REALIZATIONS_FAILED
                     )
+                    experiment_status = ExperimentStatus(
+                        message="Too few realizations are evaluated successfully"
+                        if self.get_number_of_successful_realizations() > 0
+                        else "All realizations failed",
+                        status=ExperimentState.failed,
+                    )
                 case _:
                     self._exit_code = EverestExitCode.COMPLETED
+                    experiment_status = ExperimentStatus(
+                        message="Experiment completed", status=ExperimentState.completed
+                    )
+
+        if experiment_status is not None:
+            self._experiment.status = experiment_status
 
         logger.debug(
             f"Everest experiment finished with exit code {self._exit_code.name}"
@@ -640,10 +764,10 @@ class EverestRunModel(RunModel):
 
     def _create_optimizer(self) -> tuple[BasicOptimizer, list[float]]:
         enopt_config, initial_guesses = everest2ropt(
-            self.controls,
-            self.objective_functions,
+            cast(list[EverestControl], self.parameter_configuration),
+            self.objectives_config,
             self.input_constraints,
-            self.output_constraints,
+            self.output_constraints_config,
             self.optimization,
             self.model,
             self.random_seed,
@@ -710,18 +834,13 @@ class EverestRunModel(RunModel):
         for sim_id in range(sim_to_control_vector.shape[0]):
             sim_controls = sim_to_control_vector[sim_id]
             offset = 0
-            for control_config in self.controls:
-                ext_param_config = next(
-                    c
-                    for c in self.parameter_configuration
-                    if c.name == control_config.name
-                )
-                n_param_keys = len(ext_param_config.parameter_keys)
+            for control_config in self._everest_control_configs:
+                n_param_keys = len(control_config.parameter_keys)
 
                 # Save controls to ensemble
                 ensemble.save_parameters_numpy(
                     sim_controls[offset : (offset + n_param_keys)].reshape(-1, 1),
-                    ext_param_config.name,
+                    control_config.name,
                     np.array([sim_id]),
                 )
                 offset += n_param_keys
@@ -888,15 +1007,15 @@ class EverestRunModel(RunModel):
             # Nothing to do, there may only have been inactive control vectors:
             num_all_simulations = control_values.shape[0]
             objectives = np.zeros(
-                (num_all_simulations, len(self.objective_names)),
+                (num_all_simulations, len(self.objectives_config.keys)),
                 dtype=np.float64,
             )
             constraints = (
                 np.zeros(
-                    (num_all_simulations, len(self.constraint_names)),
+                    (num_all_simulations, len(self.output_constraints_config.keys)),
                     dtype=np.float64,
                 )
-                if self.output_constraints
+                if self.output_constraints_config
                 else None
             )
             sim_ids = np.array([-1] * num_all_simulations, dtype=np.int32)
@@ -959,7 +1078,7 @@ class EverestRunModel(RunModel):
         for sim_id, (model_realization, perturbation) in enumerate(
             zip(sim_to_model_realization, sim_to_perturbation, strict=True)
         ):
-            substitutions[f"<GEO_ID_{sim_id}_{ensemble.iteration}>"] = str(
+            substitutions[f"<REALIZATION_ID_{sim_id}_{ensemble.iteration}>"] = str(
                 int(model_realization)
             )
             if perturbation >= 0:
@@ -1006,10 +1125,14 @@ class EverestRunModel(RunModel):
     def _gather_simulation_results(
         self, ensemble: Ensemble
     ) -> tuple[NDArray[np.float64], NDArray[np.float64] | None]:
-        objective_names = self.objective_names
+        objective_names = self.objectives_config.keys
         objectives = np.zeros((ensemble.ensemble_size, len(objective_names)))
 
-        constraint_names = self.constraint_names
+        constraint_names = (
+            self.output_constraints_config.keys
+            if self.output_constraints_config is not None
+            else []
+        )
         constraints = np.zeros((ensemble.ensemble_size, len(constraint_names)))
 
         if not any(self.active_realizations):
@@ -1046,3 +1169,104 @@ class EverestRunModel(RunModel):
         return os.path.exists(self.simulation_dir) and any(
             os.listdir(self.simulation_dir)
         )
+
+
+def _extract_summary_keys(ever_config: EverestConfig) -> list[str]:
+    DEFAULT_DATA_SUMMARY_KEYS = ["YEAR", "YEARS", "TCPU", "TCPUDAY", "MONTH", "DAY"]
+
+    DEFAULT_FIELD_SUMMARY_KEYS = [
+        "FOPR",
+        "FOPT",
+        "FOIR",
+        "FOIT",
+        "FWPR",
+        "FWPT",
+        "FWIR",
+        "FWIT",
+        "FGPR",
+        "FGPT",
+        "FGIR",
+        "FGIT",
+        "FVPR",
+        "FVPT",
+        "FVIR",
+        "FVIT",
+        "FWCT",
+        "FGOR",
+        "FOIP",
+        "FOIPL",
+        "FOIPG",
+        "FWIP",
+        "FGIP",
+        "FGIPL",
+        "FGIPG",
+        "FPR",
+        "FAQR",
+        "FAQRG",
+        "FAQT",
+        "FAQTG",
+        "FWGR",
+    ]
+
+    DEFAULT_WELL_SUMMARY_KEYS = [
+        "WOPR",
+        "WOPT",
+        "WOIR",
+        "WOIT",
+        "WWPR",
+        "WWPT",
+        "WWIR",
+        "WWIT",
+        "WGPR",
+        "WGPT",
+        "WGIR",
+        "WGIT",
+        "WVPR",
+        "WVPT",
+        "WVIR",
+        "WVIT",
+        "WWCT",
+        "WGOR",
+        "WWGR",
+        "WBHP",
+        "WTHP",
+        "WPI",
+    ]
+
+    DEFAULT_WELL_TARGET_SUMMARY_KEYS = [
+        well_key + "T"
+        for well_key in DEFAULT_WELL_SUMMARY_KEYS
+        if well_key.endswith("R") and well_key != "WGOR"
+    ]
+
+    summary_fms: list[ForwardModelStepConfig] = [
+        fm
+        for fm in ever_config.forward_model
+        if fm.results is not None and fm.results.type == "summary"
+    ]
+
+    if not summary_fms:
+        return []
+
+    smry_results = summary_fms[0].results
+    assert isinstance(smry_results, SummaryResults)
+
+    requested_keys: list[str] = ["*"] if smry_results.keys == "*" else smry_results.keys
+
+    well_keys = [
+        f"{sum_key}:*"
+        for sum_key in DEFAULT_WELL_SUMMARY_KEYS + DEFAULT_WELL_TARGET_SUMMARY_KEYS
+    ]
+    deprecated_user_specified_keys = (
+        [] if ever_config.export is None else ever_config.export.keywords
+    )
+
+    return list(
+        set(
+            requested_keys
+            + DEFAULT_DATA_SUMMARY_KEYS
+            + DEFAULT_FIELD_SUMMARY_KEYS
+            + well_keys
+            + deprecated_user_specified_keys
+        )
+    )