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

ert/gui/simulation/evaluate_ensemble_panel.py

@@ -5,6 +5,7 @@ import numpy as np
 from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtWidgets import QFormLayout, QLabel, QWidget
+from typing_extensions import override
 
 from ert.config import ErrorInfo
 from ert.gui.ertnotifier import ErtNotifier
@@ -13,9 +14,9 @@ from ert.gui.ertwidgets import (
     CopyableLabel,
     EnsembleSelector,
     StringBox,
+    Suggestor,
 )
 from ert.gui.simulation.experiment_config_panel import ExperimentConfigPanel
-from ert.gui.suggestor import Suggestor
 from ert.mode_definitions import EVALUATE_ENSEMBLE_MODE
 from ert.run_models.evaluate_ensemble import EvaluateEnsemble
 from ert.storage import RealizationStorageState
@@ -32,9 +33,7 @@ class Arguments:
 
 
 class EvaluateEnsemblePanel(ExperimentConfigPanel):
-    def __init__(
-        self, ensemble_size: int, run_path: str, notifier: ErtNotifier
-    ) -> None:
+    def __init__(self, run_path: str, notifier: ErtNotifier) -> None:
         self.notifier = notifier
         super().__init__(EvaluateEnsemble)
         self.setObjectName("Evaluate_parameters_panel")
@@ -49,8 +48,14 @@ class EvaluateEnsemblePanel(ExperimentConfigPanel):
         runpath_label = CopyableLabel(text=run_path)
         layout.addRow("Runpath:", runpath_label)
 
-        number_of_realizations_label = QLabel(f"<b>{ensemble_size}</b>")
-        layout.addRow(QLabel("Number of realizations:"), number_of_realizations_label)
+        ensemble_size = 0
+        if self._ensemble_selector.selected_ensemble:
+            ensemble_size = self._ensemble_selector.selected_ensemble.ensemble_size
+
+        self._number_of_realizations_label = QLabel(f"<b>{ensemble_size}</b>")
+        layout.addRow(
+            QLabel("Number of realizations:"), self._number_of_realizations_label
+        )
 
         self._active_realizations_field = StringBox(
             ActiveRealizationsModel(ensemble_size, show_default=False),  # type: ignore
@@ -58,7 +63,6 @@ class EvaluateEnsemblePanel(ExperimentConfigPanel):
         )
         self._realizations_validator = EnsembleRealizationsArgument(
             lambda: self._ensemble_selector.selected_ensemble,
-            max_value=ensemble_size,
             required_realization_storage_states=[
                 RealizationStorageState.PARAMETERS_LOADED
             ],
@@ -78,12 +82,14 @@ class EvaluateEnsemblePanel(ExperimentConfigPanel):
         )
         self._ensemble_selector.currentIndexChanged.connect(self._realizations_from_fs)
 
+    @override
     def isConfigurationValid(self) -> bool:
         return (
             self._active_realizations_field.isValid()
             and self._ensemble_selector.currentIndex() != -1
         )
 
+    @override
     def get_experiment_arguments(self) -> Arguments:
         assert self._ensemble_selector.selected_ensemble is not None
         return Arguments(
@@ -106,6 +112,9 @@ class EvaluateEnsemblePanel(ExperimentConfigPanel):
                 if not any(mask):
                     mask = parameters
                 self._active_realizations_field.model.setValueFromMask(mask)  # type: ignore
+                self._number_of_realizations_label.setText(
+                    f"<b>{ensemble.ensemble_size}</b>"
+                )
         except OSError as err:
             logger.error(str(err))
             Suggestor(
@@ -114,6 +123,7 @@ class EvaluateEnsemblePanel(ExperimentConfigPanel):
                 parent=self,
             ).show()
 
+    @override
     @Slot(QWidget)
     def experimentTypeChanged(self, w: QWidget) -> None:
         if isinstance(w, EvaluateEnsemblePanel):

ert/gui/simulation/experiment_panel.py

@@ -55,9 +55,15 @@ def create_md_table(kv: dict[str, str], output: str) -> str:
 
 
 def get_simulation_thread(
-    model: Any, rerun_failed_realizations: bool = False, use_ipc_protocol: bool = False
+    model: Any,
+    rerun_failed_realizations: bool = False,
+    use_ipc_protocol: bool = False,
+    prioritize_private_ip_address: bool = False,
 ) -> ErtThread:
-    evaluator_server_config = EvaluatorServerConfig(use_ipc_protocol=use_ipc_protocol)
+    evaluator_server_config = EvaluatorServerConfig(
+        use_ipc_protocol=use_ipc_protocol,
+        prioritize_private_ip_address=prioritize_private_ip_address,
+    )
 
     def run() -> None:
         model.api.start_simulations_thread(
@@ -158,7 +164,6 @@ class ExperimentPanel(QWidget):
             True,
         )
 
-        ensemble_size = config.ensemble_size
         active_realizations = config.active_realizations
         config_num_realization = config.runpath_config.num_realizations
         self.addExperimentConfigPanel(
@@ -173,7 +178,7 @@ class ExperimentPanel(QWidget):
             True,
         )
         self.addExperimentConfigPanel(
-            EvaluateEnsemblePanel(ensemble_size, run_path, notifier),
+            EvaluateEnsemblePanel(run_path, notifier),
             True,
         )
 
@@ -215,7 +220,7 @@ class ExperimentPanel(QWidget):
             experiment_type_valid,
         )
         self.addExperimentConfigPanel(
-            ManualUpdatePanel(ensemble_size, run_path, notifier, analysis_config),
+            ManualUpdatePanel(run_path, notifier, analysis_config),
             experiment_type_valid,
         )
 
@@ -355,6 +360,10 @@ class ExperimentPanel(QWidget):
                         return
                 QApplication.restoreOverrideCursor()
 
+        self.configuration_summary.log_summary(
+            args.mode, model.get_number_of_active_realizations()
+        )
+
         self._dialog = RunDialog(
             f"Experiment - {self._config_file} {find_ert_info()}",
             model.api,
@@ -365,7 +374,9 @@ class ExperimentPanel(QWidget):
             run_path=Path(self.config.runpath_config.runpath_format_string),
             storage_path=self._notifier.storage.path,
         )
-        self._dialog.set_queue_system_name(model.queue_system)
+        self._dialog.queue_system.setText(
+            f"Queue system:\n{model.queue_config.queue_system.formatted_name}"
+        )
         self.experiment_started.emit(self._dialog)
         self._simulation_done = False
         self.run_button.setEnabled(self._simulation_done)
@@ -376,6 +387,7 @@ class ExperimentPanel(QWidget):
                 rerun_failed_realizations,
                 use_ipc_protocol=self.config.queue_config.queue_system
                 == QueueSystem.LOCAL,
+                prioritize_private_ip_address=self.config.prioritize_private_ip_address,
             )
             self._dialog.setup_event_monitoring(rerun_failed_realizations)
             simulation_thread.start()

ert/gui/simulation/manual_update_panel.py

@@ -3,9 +3,10 @@ from dataclasses import dataclass
 from typing import cast
 
 import numpy as np
-from PyQt6.QtCore import Qt
+from PyQt6.QtCore import pyqtSignal
 from PyQt6.QtCore import pyqtSlot as Slot
-from PyQt6.QtWidgets import QFormLayout, QLabel, QWidget
+from PyQt6.QtWidgets import QComboBox, QFormLayout, QLabel, QWidget
+from typing_extensions import override
 
 from ert.config import AnalysisConfig, ErrorInfo
 from ert.gui.ertnotifier import ErtNotifier
@@ -15,11 +16,11 @@ from ert.gui.ertwidgets import (
     CopyableLabel,
     EnsembleSelector,
     StringBox,
+    Suggestor,
     TargetEnsembleModel,
 )
 from ert.gui.simulation.experiment_config_panel import ExperimentConfigPanel
-from ert.gui.suggestor import Suggestor
-from ert.mode_definitions import MANUAL_UPDATE_MODE
+from ert.mode_definitions import MANUAL_ENIF_UPDATE_MODE, MANUAL_UPDATE_MODE
 from ert.run_models.manual_update import ManualUpdate
 from ert.storage import Ensemble, RealizationStorageState
 from ert.validation import EnsembleRealizationsArgument, ProperNameFormatArgument
@@ -37,9 +38,10 @@ class Arguments:
 
 
 class ManualUpdatePanel(ExperimentConfigPanel):
+    updateMethodChanged = pyqtSignal(str)
+
     def __init__(
         self,
-        ensemble_size: int,
         run_path: str,
         notifier: ErtNotifier,
         analysis_config: AnalysisConfig,
@@ -49,9 +51,17 @@ class ManualUpdatePanel(ExperimentConfigPanel):
         self.setObjectName("Manual_update_panel")
 
         layout = QFormLayout()
-        lab = QLabel(ManualUpdate.name())
-        lab.setAlignment(Qt.AlignmentFlag.AlignLeft)
-        layout.addRow(lab)
+        self._update_method_dropdown = QComboBox()
+        self._update_method_dropdown.addItems(
+            ["ES Update", "EnIF Update (Experimental)"]
+        )
+        self._update_method_dropdown.currentTextChanged.connect(
+            self._on_update_method_changed
+        )
+        self._update_method_dropdown.setObjectName("manual_update_method_dropdown")
+
+        layout.addRow("Update method:", self._update_method_dropdown)
+
         self._ensemble_selector = EnsembleSelector(
             notifier, show_only_with_response_data=True
         )
@@ -97,15 +107,30 @@ class ManualUpdatePanel(ExperimentConfigPanel):
         self._ensemble_selector.currentIndexChanged.connect(self._realizations_from_fs)
         self.setLayout(layout)
 
+    @property
+    def selected_update_method(self) -> str:
+        return self._update_method_dropdown.currentText()
+
+    @Slot(str)
+    def _on_update_method_changed(self, new_method: str) -> None:
+        if new_method == "ES Update":
+            self._analysis_module_edit.show()
+        else:
+            self._analysis_module_edit.hide()
+
+    @override
     def isConfigurationValid(self) -> bool:
         return (
             self._active_realizations_field.isValid()
             and self._ensemble_selector.currentIndex() != -1
         )
 
+    @override
     def get_experiment_arguments(self) -> Arguments:
         return Arguments(
-            mode=MANUAL_UPDATE_MODE,
+            mode=MANUAL_UPDATE_MODE
+            if self.selected_update_method == "ES Update"
+            else MANUAL_ENIF_UPDATE_MODE,
             ensemble_id=str(
                 cast(Ensemble, self._ensemble_selector.selected_ensemble).id
             ),
@@ -126,7 +151,6 @@ class ManualUpdatePanel(ExperimentConfigPanel):
                 self._active_realizations_field.setValidator(
                     EnsembleRealizationsArgument(
                         lambda: ensemble,
-                        max_value=ensemble.ensemble_size,
                         required_realization_storage_states=[
                             RealizationStorageState.PARAMETERS_LOADED,
                             RealizationStorageState.RESPONSES_LOADED,
@@ -148,6 +172,7 @@ class ManualUpdatePanel(ExperimentConfigPanel):
                 parent=self,
             ).show()
 
+    @override
     @Slot(QWidget)
     def experimentTypeChanged(self, w: QWidget) -> None:
         if isinstance(w, ManualUpdatePanel):

ert/gui/simulation/multiple_data_assimilation_panel.py

@@ -8,6 +8,7 @@ from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtGui import QFont
 from PyQt6.QtWidgets import QCheckBox, QFormLayout, QHBoxLayout, QLabel, QWidget
+from typing_extensions import override
 
 from ert.config import ErrorInfo, ParameterConfig
 from ert.gui.ertnotifier import ErtNotifier
@@ -17,14 +18,14 @@ from ert.gui.ertwidgets import (
     CopyableLabel,
     EnsembleSelector,
     StringBox,
+    Suggestor,
     TargetEnsembleModel,
     TextModel,
     ValueModel,
+    get_parameters_button,
 )
-from ert.gui.ertwidgets.parameterviewer import get_parameters_button
-from ert.gui.suggestor import Suggestor
 from ert.mode_definitions import ES_MDA_MODE
-from ert.run_models import MultipleDataAssimilation
+from ert.run_models import MultipleDataAssimilation, MultipleDataAssimilationConfig
 from ert.storage.realization_storage_state import RealizationStorageState
 from ert.validation import (
     ExperimentValidation,
@@ -113,7 +114,7 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
         self._target_ensemble_format_field.setValidator(ProperNameFormatArgument())
         layout.addRow("Target ensemble format:", self._target_ensemble_format_field)
 
-        self.weights = MultipleDataAssimilation.default_weights
+        self.weights = MultipleDataAssimilationConfig.default_weights
         self.weights_valid = True
         self._createInputForWeights(layout)
 
@@ -139,7 +140,6 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
         self._ensemble_selector = EnsembleSelector(notifier)
         self._previous_ensemble_realizations_validator = EnsembleRealizationsArgument(
             lambda: self._ensemble_selector.selected_ensemble,
-            max_value=len(active_realizations),
             required_realization_storage_states=[
                 RealizationStorageState.RESPONSES_LOADED
             ],
@@ -189,12 +189,14 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
                 merged_parameters
             )
 
-        layout.addRow("Parameters:", get_parameters_button(merged_parameters, self))
+        if merged_parameters:
+            layout.addRow("Parameters", get_parameters_button(merged_parameters, self))
 
         self.setLayout(layout)
 
         self.notifier.ertChanged.connect(self._update_experiment_name_placeholder)
 
+    @override
     @Slot(QWidget)
     def experimentTypeChanged(self, w: QWidget) -> None:
         if isinstance(w, MultipleDataAssimilationPanel):
@@ -215,7 +217,7 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
 
             self._relative_iteration_weights_box.setText(
                 self._ensemble_selector.selected_ensemble.relative_weights
-                or MultipleDataAssimilation.default_weights
+                or MultipleDataAssimilationConfig.default_weights
             )
             self._evaluate_weights_box_enabled()
 
@@ -250,9 +252,9 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
                 self._ensemble_selector.selected_ensemble is not None
                 and self._ensemble_selector.selected_ensemble.relative_weights
             )
-            or MultipleDataAssimilation.default_weights
+            or MultipleDataAssimilationConfig.default_weights
             if self._restart_box.isChecked()
-            else MultipleDataAssimilation.default_weights
+            else MultipleDataAssimilationConfig.default_weights
         )
         if self._restart_box.isChecked():
             self._active_realizations_field.setValidator(
@@ -307,6 +309,7 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
 
         updateVisualizationOfNormalizedWeights()  # To normalize the default weights
 
+    @override
     def isConfigurationValid(self) -> bool:
         return (
             self._experiment_name_field.isValid()
@@ -316,6 +319,7 @@ class MultipleDataAssimilationPanel(ExperimentConfigPanel):
             and self.weights_valid
         )
 
+    @override
     def get_experiment_arguments(self) -> Arguments:
         return Arguments(
             mode=ES_MDA_MODE,

ert/gui/simulation/run_dialog.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import logging
+from datetime import datetime
 from pathlib import Path
 from queue import SimpleQueue
-from typing import assert_never, cast
+from typing import cast
 
 import humanize
 from PyQt6.QtCore import QModelIndex, QSize, Qt, QThread, QTimer
@@ -28,16 +29,20 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
-from ert.config import ErrorInfo, QueueSystem, WarningInfo
+from _ert.events import EnsembleEvaluationWarning
+from ert.config import ErrorInfo, WarningInfo
 from ert.ensemble_evaluator import (
     EndEvent,
     FullSnapshotEvent,
     SnapshotUpdateEvent,
+    StartEvent,
     WarningEvent,
 )
 from ert.ensemble_evaluator import identifiers as ids
 from ert.gui.ertnotifier import ErtNotifier
+from ert.gui.ertwidgets import Suggestor
 from ert.gui.model.fm_step_list import FMStepListProxyModel
 from ert.gui.model.node import IterNode
 from ert.gui.model.real_list import RealListModel
@@ -48,7 +53,6 @@ from ert.gui.model.snapshot import (
     RealIens,
     SnapshotModel,
 )
-from ert.gui.suggestor import Suggestor
 from ert.gui.tools.file import FileDialog
 from ert.run_models import (
     RunModelAPI,
@@ -175,6 +179,7 @@ class FMStepOverview(QTableView):
             error_textedit.moveCursor(QTextCursor.MoveOperation.Start)
             error_dialog.exec()
 
+    @override
     def mouseMoveEvent(self, e: QMouseEvent | None) -> None:
         if e:
             index = self.indexAt(e.pos())
@@ -256,6 +261,7 @@ class RunDialog(QFrame):
         self._fm_step_label.setObjectName("fm_step_label")
         self._fm_step_overview = FMStepOverview(self._snapshot_model, self)
 
+        self._start_time: datetime | None = None
         self.running_time = QLabel("Running time:\n -")
         self.running_time.setMinimumWidth(150)
         self.queue_system = QLabel("")
@@ -266,6 +272,9 @@ class RunDialog(QFrame):
         self.kill_button = QPushButton("Terminate experiment")
         self.rerun_button = QPushButton("Rerun failed simulations")
         self.rerun_button.setEnabled(False)
+        self.show_warnings_button = QPushButton()
+        self.set_show_warning_button_to_initial_state()
+        self.show_warnings_button.clicked.connect(self.toggle_fail_message_box)
 
         size = 20
         spin_movie = QMovie("img:loading.gif")
@@ -309,6 +318,7 @@ class RunDialog(QFrame):
         button_layout = QVBoxLayout()
         button_layout.addWidget(self.kill_button)
         button_layout.addWidget(self.rerun_button)
+        button_layout.addWidget(self.show_warnings_button)
         footer_layout.addLayout(button_layout)
 
         footer_widget_container = QWidget()
@@ -478,6 +488,7 @@ class RunDialog(QFrame):
         if failed:
             self.update_total_progress(1.0, "Failed")
             self._progress_widget.set_all_failed()
+            self.show_warnings_button.setText("Show errors")
         else:
             self.update_total_progress(1.0, "Experiment completed.")
 
@@ -495,6 +506,8 @@ class RunDialog(QFrame):
                 ),
                 parent=self,
             )
+            self.show_warnings_button.setEnabled(True)
+            self.show_warnings_button.setToolTip("")
             self.fail_msg_box.show()
 
         if self.post_simulation_warnings:
@@ -503,11 +516,23 @@ class RunDialog(QFrame):
                 f"{len(self.post_simulation_warnings)} PostSimulationWarnings"
             )
 
+    def set_show_warning_button_to_initial_state(self) -> None:
+        self.show_warnings_button.setEnabled(False)
+        self.show_warnings_button.setText("Show warnings")
+        self.show_warnings_button.setToolTip("No warnings to show")
+
+    def toggle_fail_message_box(self) -> None:
+        if self.fail_msg_box is None:
+            return
+        self.fail_msg_box.setVisible(not self.fail_msg_box.isVisible())
+
     @Slot()
     def _on_ticker(self) -> None:
-        runtime = self._run_model_api.get_runtime()
-        running_time = f"Running time: {humanize.precisedelta(runtime)}"
-        self.running_time.setText(running_time[0:14] + "\n" + running_time[14:])
+        if self._start_time:
+            humanized_runtime = humanize.precisedelta(
+                datetime.now() - self._start_time, minimum_unit="seconds", format="%d"
+            )
+            self.running_time.setText(f"Running time:\n{humanized_runtime}")
 
         maximum_memory_usage = self._snapshot_model.root.max_memory_usage
 
@@ -524,11 +549,16 @@ class RunDialog(QFrame):
     def _on_event(self, event: object) -> None:
         model = self._snapshot_model
         match event:
+            case StartEvent():
+                self._start_time = event.timestamp
             case EndEvent(failed=failed, msg=msg):
                 self.simulation_done.emit(failed, msg)
                 self._ticker.stop()
             case WarningEvent(msg=msg):
                 self.post_simulation_warnings.append(msg)
+            case EnsembleEvaluationWarning(warning_message=msg):
+                self._show_warning(msg)
+
             case FullSnapshotEvent(
                 status_count=status_count, realization_count=realization_count
             ):
@@ -634,25 +664,22 @@ class RunDialog(QFrame):
             self.post_simulation_warnings.clear()
             self._is_rerunning_failed_realizations = True
             self.rerun_failed_realizations_experiment.emit()
+            self.set_show_warning_button_to_initial_state()
 
-    def set_queue_system_name(self, queue_system: QueueSystem) -> None:
-        match queue_system:
-            case QueueSystem.LSF:
-                formatted_queue_system = "LSF"
-            case QueueSystem.LOCAL:
-                formatted_queue_system = "Local"
-            case QueueSystem.TORQUE:
-                formatted_queue_system = "Torque/OpenPBS"
-            case QueueSystem.SLURM:
-                formatted_queue_system = "Slurm"
-            case default:
-                assert_never(default)
-        self.queue_system.setText(f"Queue system:\n{formatted_queue_system}")
-
+    @override
     def hideEvent(self, event: QHideEvent | None) -> None:
         for file_dialog in self.findChildren(FileDialog):
             file_dialog.close()
 
+    def _show_warning(self, msg: str) -> None:
+        msg_box = QMessageBox(self)
+        msg_box.setObjectName("EnsembleEvaluationWarningBox")
+        msg_box.setIcon(QMessageBox.Icon.Warning)
+        msg_box.setWindowTitle("Ensemble Evaluation Warning")
+        msg_box.setText(msg)
+        msg_box.setStandardButtons(QMessageBox.StandardButton.Ok)
+        msg_box.show()
+
 
 # Cannot use a non-static method here as
 # it is called when the object is destroyed

ert/gui/simulation/single_test_run_panel.py

@@ -2,14 +2,15 @@ from dataclasses import dataclass
 
 from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import QFormLayout, QLabel
+from typing_extensions import override
 
+from ert.config import AnalysisConfig, ParameterConfig
 from ert.gui.ertnotifier import ErtNotifier
 from ert.gui.ertwidgets import CopyableLabel
 from ert.mode_definitions import TEST_RUN_MODE
 from ert.run_models import SingleTestRun
 
-from ...config import AnalysisConfig, ParameterConfig
-from ..ertwidgets.parameterviewer import get_parameters_button
+from ..ertwidgets import get_parameters_button
 from ._design_matrix_panel import DesignMatrixPanel
 from .experiment_config_panel import ExperimentConfigPanel
 
@@ -54,9 +55,11 @@ class SingleTestRunPanel(ExperimentConfigPanel):
                 merged_parameters
             )
 
-        layout.addRow("Parameters:", get_parameters_button(merged_parameters, self))
+        if merged_parameters:
+            layout.addRow("Parameters", get_parameters_button(merged_parameters, self))
 
         self.setLayout(layout)
 
+    @override
     def get_experiment_arguments(self) -> Arguments:
         return Arguments(TEST_RUN_MODE, "ensemble", "single_test_run")

ert/gui/simulation/view/progress_widget.py

@@ -8,6 +8,7 @@ from PyQt6.QtWidgets import (
     QProgressBar,
     QVBoxLayout,
 )
+from typing_extensions import override
 
 from ert.ensemble_evaluator.state import ENSEMBLE_STATE_FAILED, REAL_STATE_TO_COLOR
 
@@ -107,5 +108,6 @@ class ProgressWidget(QFrame):
             self.stop_waiting_progress_bar()
         self.repaint_components()
 
+    @override
     def resizeEvent(self, a0: QResizeEvent | None) -> None:
         self.repaint_components()

ert/gui/simulation/view/realization.py

@@ -22,6 +22,7 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.gui.model.real_list import RealListModel
 from ert.gui.model.snapshot import (
@@ -105,6 +106,7 @@ class RealizationDelegate(QStyledItemDelegate):
         self._color_lightgray = QColor("LightGray").lighter(120)
         self._pen_black = QPen(self._color_black, 2, Qt.PenStyle.SolidLine)
 
+    @override
     def paint(
         self, painter: QPainter | None, option: QStyleOptionViewItem, index: QModelIndex
     ) -> None:
@@ -158,10 +160,12 @@ class RealizationDelegate(QStyledItemDelegate):
 
         painter.restore()
 
+    @override
     def sizeHint(self, option: QStyleOptionViewItem, index: QModelIndex) -> QSize:
         return self._size
 
-    def eventFilter(self, object: QObject | None, event: QEvent | None) -> bool:  # noqa: A002
+    @override
+    def eventFilter(self, object: QObject | None, event: QEvent | None) -> bool:
         if isinstance(event, QHelpEvent) and event.type() == QEvent.Type.ToolTip:
             mouse_pos = event.pos() + self.adjustment_point_for_job_rect_margin
             parent: RealizationWidget = cast(RealizationWidget, self.parent())

ert/gui/simulation/view/update.py

@@ -25,6 +25,7 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.analysis.event import DataSection
 from ert.ensemble_evaluator import state
@@ -56,6 +57,7 @@ class UpdateLogTable(QTableWidget):
             for j, val in enumerate(row):
                 self.setItem(i, j, QTableWidgetItem(str(val)))
 
+    @override
     def keyPressEvent(self, e: QKeyEvent | None) -> None:
         if e is not None and e.matches(QKeySequence.StandardKey.Copy):
             stream = ""

ert/gui/summarypanel.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 from PyQt6.QtCore import Qt
@@ -13,11 +14,13 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ert.gui.ertwidgets.models.ertsummary import ErtSummary
+from ert.gui.ertwidgets import ErtSummary
 
 if TYPE_CHECKING:
     from ert.config import ErtConfig
 
+logger = logging.getLogger(__name__)
+
 
 class SummaryTemplate:
     def __init__(self, title: str) -> None:
@@ -123,6 +126,22 @@ class SummaryPanel(QFrame):
 
         self._layout.addLayout(layout)
 
+    def log_summary(self, run_model: str, num_realizations: int) -> None:
+        summary = ErtSummary(self.config)
+
+        observations = summary.getObservations()
+        observations_count = sum(e["count"] for e in observations)
+
+        _, parameter_count = summary.get_parameters()
+
+        logger.info(
+            f"Experiment summary:\n"
+            f"Runmodel: {run_model}\n"
+            f"Realizations: {num_realizations}\n"
+            f"Parameters: {parameter_count}\n"
+            f"Observations: {observations_count}"
+        )
+
     @staticmethod
     def _runlength_encode_list(strings: list[str]) -> list[tuple[str, int]]:
         """Runlength encode a list of strings.