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

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
@@ -30,15 +31,18 @@ from PyQt6.QtWidgets import (
 )
 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
@@ -49,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,
@@ -258,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("")
@@ -524,9 +528,11 @@ class RunDialog(QFrame):
 
     @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
 
@@ -543,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
             ):
@@ -650,29 +661,25 @@ class RunDialog(QFrame):
         if result == QMessageBox.StandardButton.Ok:
             self.rerun_button.setEnabled(False)
             self.kill_button.setEnabled(True)
+            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

@@ -4,13 +4,13 @@ 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
 

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.

ert/gui/tools/load_results/load_results_panel.py

@@ -13,10 +13,10 @@ from ert.gui.ertwidgets import (
     EnsembleSelector,
     QApplication,
     StringBox,
+    Suggestor,
     TextBox,
     TextModel,
 )
-from ert.gui.suggestor import Suggestor
 from ert.run_models.run_model import captured_logs
 from ert.storage.local_ensemble import load_parameters_and_responses_from_runpath
 from ert.validation import RangeStringArgument, StringDefinition

ert/gui/tools/manage_experiments/export_dialog.py

@@ -0,0 +1,136 @@
+import contextlib
+from pathlib import Path
+from typing import cast
+
+import polars as pl
+from PyQt6.QtCore import (
+    Qt,
+)
+from PyQt6.QtCore import (
+    pyqtSlot as Slot,
+)
+from PyQt6.QtGui import QColor, QPalette
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QFileDialog,
+    QHBoxLayout,
+    QLineEdit,
+    QPushButton,
+    QTextEdit,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class ExportDialog(QDialog):
+    """Base dialog for exporting ensemble-related data to files."""
+
+    def __init__(
+        self,
+        export_data: pl.DataFrame,
+        window_title: str = "Export data",
+        parent: QWidget | None = None,
+    ) -> None:
+        QDialog.__init__(self, parent)
+        self._export_data = export_data
+        self.setWindowTitle(window_title)
+
+        self.setWindowFlags(Qt.WindowType.Dialog)
+        self.setModal(True)
+        self.setMinimumWidth(450)
+        self.setMinimumHeight(200)
+
+        main_layout = QVBoxLayout()
+
+        file_layout = QHBoxLayout()
+        self._file_path_edit = QLineEdit(self)
+        self._file_path_edit.setPlaceholderText("Select output file...")
+        self._file_path_edit.textChanged.connect(self.validate_file)
+        browse_button = QPushButton("Browse...", self)
+        browse_button.clicked.connect(self.browse_file)
+        file_layout.addWidget(self._file_path_edit)
+        file_layout.addWidget(browse_button)
+        main_layout.addLayout(file_layout)
+
+        self._export_text_area = QTextEdit(self)
+        self._export_text_area.setReadOnly(True)
+        self._export_text_area.setFixedHeight(100)
+        main_layout.addWidget(self._export_text_area)
+
+        button_box = QDialogButtonBox(self)
+        button_box.setStandardButtons(QDialogButtonBox.StandardButton.Cancel)
+        button_box.rejected.connect(self.cancel)
+
+        self._export_button = cast(
+            QPushButton,
+            button_box.addButton("Export", QDialogButtonBox.ButtonRole.AcceptRole),
+        )
+        self._export_button.clicked.connect(self.export)
+        self._export_button.setEnabled(False)  # Initially disabled
+        main_layout.addWidget(button_box)
+
+        self.setLayout(main_layout)
+
+    @Slot()
+    def export(self) -> None:
+        self._export_text_area.insertPlainText("Exporting...\n")
+        try:
+            output_file: str = self._file_path_edit.text().strip()
+            self._export_button.setEnabled(False)
+            self._export_data.write_csv(output_file, float_precision=6)
+            self._export_text_area.insertPlainText(f"Data exported to: {output_file}\n")
+        except Exception as e:
+            self._export_text_area.insertHtml(
+                f"<span style='color: red;'>Could not export data: {e!s}</span><br>"
+            )
+        finally:
+            self._export_button.setEnabled(True)
+
+    @Slot()
+    def cancel(self) -> None:
+        self.reject()
+
+    @Slot()
+    def validate_file(self) -> None:
+        """Validation to check if the file path is not empty or invalid."""
+
+        def _set_invalid(tooltip_text: str = "Invalid file path") -> None:
+            palette = self._file_path_edit.palette()
+            palette.setColor(QPalette.ColorRole.Text, QColor("red"))
+            self._file_path_edit.setPalette(palette)
+            self._file_path_edit.setToolTip(tooltip_text)
+            self._export_button.setToolTip(tooltip_text)
+            self._export_button.setEnabled(False)
+
+        def _set_valid() -> None:
+            palette = self._file_path_edit.palette()
+            palette.setColor(QPalette.ColorRole.Text, QColor("black"))
+            self._file_path_edit.setPalette(palette)
+            self._file_path_edit.setToolTip("")
+            self._export_button.setToolTip("")
+            self._export_button.setEnabled(True)
+
+        path = Path(self._file_path_edit.text().strip())
+        if str(path) in {"", "."}:
+            _set_invalid(tooltip_text="No filename provided")
+            return
+
+        if path.is_dir():
+            _set_invalid(tooltip_text=f"'{path!s}' is an existing directory.")
+            return
+
+        with contextlib.suppress(Exception):
+            if path.parent.is_dir():
+                _set_valid()
+                return
+
+        _set_invalid()
+
+    @Slot()
+    def browse_file(self) -> None:
+        file_path, _ = QFileDialog.getSaveFileName(
+            self, "Select Output File", "", "All Files (*)"
+        )
+        if file_path:
+            self._file_path_edit.setText(file_path)

ert/gui/tools/manage_experiments/storage_info_widget.py

@@ -1,3 +1,4 @@
+import contextlib
 import json
 from enum import IntEnum
 
@@ -6,13 +7,18 @@ import seaborn as sns
 import yaml
 from matplotlib.backends.backend_qt5agg import FigureCanvas  # type: ignore
 from matplotlib.figure import Figure
+from polars import DataFrame
 from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSlot as Slot
 from PyQt6.QtWidgets import (
+    QAbstractItemView,
     QFrame,
     QHBoxLayout,
     QLabel,
+    QPushButton,
     QStackedLayout,
+    QTableWidget,
+    QTableWidgetItem,
     QTabWidget,
     QTextEdit,
     QTreeWidget,
@@ -21,8 +27,11 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ert import LibresFacade
 from ert.storage import Ensemble, Experiment, RealizationStorageState
 
+from .export_dialog import ExportDialog
+
 
 class _WidgetType(IntEnum):
     EMPTY_WIDGET = 0
@@ -42,6 +51,8 @@ class _EnsembleWidgetTabs(IntEnum):
     ENSEMBLE_TAB = 0
     STATE_TAB = 1
     OBSERVATIONS_TAB = 2
+    PARAMETERS_TAB = 3
+    MISFIT_TAB = 4
 
 
 class _ExperimentWidget(QWidget):
@@ -126,12 +137,15 @@ class _EnsembleWidget(QWidget):
 
         info_frame.setLayout(info_layout)
 
+        state_frame = QFrame()
+        state_layout = QHBoxLayout()
         self._state_text_edit = QTextEdit()
         self._state_text_edit.setReadOnly(True)
         self._state_text_edit.setObjectName("ensemble_state_text")
+        state_layout.addWidget(self._state_text_edit)
+        state_frame.setLayout(state_layout)
 
         observations_frame = QFrame()
-
         self._observations_tree_widget = QTreeWidget(self)
         self._observations_tree_widget.currentItemChanged.connect(
             self._currentItemChanged
@@ -151,15 +165,38 @@ class _EnsembleWidget(QWidget):
         observations_layout.addWidget(self._canvas)
         observations_frame.setLayout(observations_layout)
 
+        self._parameters_table = QTableWidget()
+        self._parameters_table.setEditTriggers(
+            QAbstractItemView.EditTrigger.NoEditTriggers
+        )
+        self._export_params_button = QPushButton("Export...")
+        self._export_params_button.clicked.connect(self.onClickExportParameters)
+
+        parameters_frame = self.create_export_frame(
+            self._parameters_table, self._export_params_button
+        )
+
+        self._misfit_table = QTableWidget()
+        self._export_misfit_button = QPushButton("Export...")
+        self._export_misfit_button.clicked.connect(self.onClickExportMisfit)
+
+        misfit_frame = self.create_export_frame(
+            self._misfit_table, self._export_misfit_button
+        )
+
         self._tab_widget = QTabWidget()
         self._tab_widget.insertTab(
             _EnsembleWidgetTabs.ENSEMBLE_TAB, info_frame, "Ensemble"
         )
+        self._tab_widget.insertTab(_EnsembleWidgetTabs.STATE_TAB, state_frame, "State")
         self._tab_widget.insertTab(
-            _EnsembleWidgetTabs.STATE_TAB, self._state_text_edit, "State"
+            _EnsembleWidgetTabs.OBSERVATIONS_TAB, observations_frame, "Observations"
         )
         self._tab_widget.insertTab(
-            _EnsembleWidgetTabs.OBSERVATIONS_TAB, observations_frame, "Observations"
+            _EnsembleWidgetTabs.PARAMETERS_TAB, parameters_frame, "Parameters"
+        )
+        self._tab_widget.insertTab(
+            _EnsembleWidgetTabs.MISFIT_TAB, misfit_frame, "Misfit"
         )
         self._tab_widget.currentChanged.connect(self._currentTabChanged)
 
@@ -168,6 +205,17 @@ class _EnsembleWidget(QWidget):
 
         self.setLayout(layout)
 
+    def create_export_frame(self, table: QTableWidget, button: QPushButton) -> QFrame:
+        export_frame = QFrame()
+        export_layout = QVBoxLayout()
+        vertical_header = table.verticalHeader()
+        assert vertical_header is not None
+        vertical_header.setVisible(False)
+        export_layout.addWidget(table)
+        export_layout.addWidget(button)
+        export_frame.setLayout(export_layout)
+        return export_frame
+
     def _currentItemChanged(
         self, selected: QTreeWidgetItem, _: QTreeWidgetItem
     ) -> None:
@@ -189,9 +237,9 @@ class _EnsembleWidget(QWidget):
 
         response_type, obs_for_type = next(
             (
-                (response_type, _df)
-                for response_type, _df in observations_dict.items()
-                if observation_key in _df["observation_key"]
+                (response_type, df)
+                for response_type, df in observations_dict.items()
+                if observation_key in df["observation_key"]
             ),
             (None, None),
         )
@@ -356,12 +404,53 @@ class _EnsembleWidget(QWidget):
                         0, Qt.SortOrder.AscendingOrder
                     )
 
-        for i in range(self._observations_tree_widget.topLevelItemCount()):
-            item = self._observations_tree_widget.topLevelItem(i)
-            assert item is not None
-            if item.childCount() > 0:
-                self._observations_tree_widget.setCurrentItem(item.child(0))
-                break
+            for i in range(self._observations_tree_widget.topLevelItemCount()):
+                item = self._observations_tree_widget.topLevelItem(i)
+                assert item is not None
+                if item.childCount() > 0:
+                    self._observations_tree_widget.setCurrentItem(item.child(0))
+                    break
+
+        elif index in {
+            _EnsembleWidgetTabs.PARAMETERS_TAB,
+            _EnsembleWidgetTabs.MISFIT_TAB,
+        }:
+            assert self._ensemble is not None
+
+            df: pl.DataFrame = pl.DataFrame()
+            with contextlib.suppress(Exception):
+                if index == _EnsembleWidgetTabs.PARAMETERS_TAB:
+                    df = self._ensemble.load_scalar_keys(transformed=True)
+                else:
+                    df = self.get_misfit_df()
+
+            table = (
+                self._parameters_table
+                if index == _EnsembleWidgetTabs.PARAMETERS_TAB
+                else self._misfit_table
+            )
+
+            table.setUpdatesEnabled(False)
+            table.setSortingEnabled(False)
+            table.setRowCount(df.height)
+            table.setColumnCount(df.width)
+            table.setHorizontalHeaderLabels(df.columns)
+
+            rows = df.rows()
+            for r, row in enumerate(rows):
+                for c, v in enumerate(row):
+                    table.setItem(r, c, QTableWidgetItem("" if v is None else str(v)))
+
+            table.resizeColumnsToContents()
+            table.setUpdatesEnabled(True)
+
+    def get_misfit_df(self) -> DataFrame:
+        assert self._ensemble is not None
+        df = LibresFacade.load_all_misfit_data(self._ensemble)
+        realization_column = pl.Series(df.index)
+        df = pl.from_pandas(df)
+        df.insert_column(0, realization_column)
+        return df
 
     @Slot(Ensemble)
     def setEnsemble(self, ensemble: Ensemble) -> None:
@@ -372,6 +461,22 @@ class _EnsembleWidget(QWidget):
 
         self._tab_widget.setCurrentIndex(0)
 
+    @Slot()
+    def onClickExportMisfit(self) -> None:
+        assert self._ensemble is not None
+        misfit_df = self.get_misfit_df()
+        export_dialog = ExportDialog(misfit_df, "Export misfit", parent=self)
+        export_dialog.show()
+
+    @Slot()
+    def onClickExportParameters(self) -> None:
+        assert self._ensemble is not None
+        parameters_df = self._ensemble.load_scalar_keys(transformed=True)
+        export_dialog = ExportDialog(
+            parameters_df, window_title="Export parameters", parent=self
+        )
+        export_dialog.show()
+
 
 class _RealizationWidget(QWidget):
     def __init__(self) -> None:
@@ -418,14 +523,14 @@ class _RealizationWidget(QWidget):
         )
 
         html = "<table>"
-        for name, _response_state in ensemble.get_response_state(realization).items():
-            html += f"<tr><td>{name} - {_response_state.name}</td></tr>"
+        for name, response_state in ensemble.get_response_state(realization).items():
+            html += f"<tr><td>{name} - {response_state.name}</td></tr>"
         html += "</table>"
         self._response_text_edit.setHtml(html)
 
         html = "<table>"
-        for name, _param_state in ensemble.get_parameter_state(realization).items():
-            html += f"<tr><td>{name} - {_param_state.name}</td></tr>"
+        for name, param_state in ensemble.get_parameter_state(realization).items():
+            html += f"<tr><td>{name} - {param_state.name}</td></tr>"
         html += "</table>"
         self._parameter_text_edit.setHtml(html)
 

ert/gui/tools/manage_experiments/storage_widget.py

@@ -24,8 +24,7 @@ from PyQt6.QtWidgets import (
 
 from ert.config import ErrorInfo, ErtConfig
 from ert.gui.ertnotifier import ErtNotifier
-from ert.gui.ertwidgets.create_experiment_dialog import CreateExperimentDialog
-from ert.gui.suggestor import Suggestor
+from ert.gui.ertwidgets import CreateExperimentDialog, Suggestor
 from ert.storage import Ensemble, Experiment
 
 from .storage_model import (