ert 19.0.0rc4__py3-none-any.whl → 20.0.0b0__py3-none-any.whl

ert/field_utils/field_utils.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import math
 import os
+from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, NamedTuple, TypeAlias
 
 import numpy as np
 import resfo
-from pydantic.dataclasses import dataclass
 
 from .field_file_format import ROFF_FORMATS, FieldFileFormat
 from .grdecl_io import export_grdecl, import_bgrdecl, import_grdecl
@@ -356,119 +356,3 @@ def localization_scaling_function(
     scaling_factor[distances > 2] = 0.0
 
     return scaling_factor
-
-
-def calc_rho_for_2d_grid_layer(
-    nx: int,
-    ny: int,
-    xinc: float,
-    yinc: float,
-    obs_xpos: npt.NDArray[np.float64],
-    obs_ypos: npt.NDArray[np.float64],
-    obs_main_range: npt.NDArray[np.float64],
-    obs_perp_range: npt.NDArray[np.float64],
-    obs_anisotropy_angle: npt.NDArray[np.float64],
-    right_handed_grid_indexing: bool = True,
-) -> npt.NDArray[np.float64]:
-    """Calculate scaling values (RHO matrix elements) for a set of observations
-    with associated localization ellipse. The method will first
-    calculate the distances from each observation position to each grid cell
-    center point of all grid cells for a 2D grid.
-    The localization method will only consider lateral distances, and it is
-    therefore sufficient to calculate the distances in 2D.
-    All input observation positions are in the local grid coordinate system
-    to simplify the calculation of the distances.
-
-    The position: xpos[n], ypos[n] and
-    localization ellipse defined by obs_main_range[n],obs_perp_range[n],
-    obs_anisotropy_angle[n]) refers to observation[n].
-
-    The distance between an observation with index n and a grid cell (i,j) is
-    d[m,n] = dist((xpos_obs[n],ypos_obs[n]),(xpos_field[i,j],ypos_field[i,j]))
-
-    RHO[[m,n] = scaling(d)
-    where m = j + i * ny for left-handed grid index origo and
-          m = (ny - j - 1) + i * ny for right-handed grid index origo
-    Note that since d[m,n] does only depend on observation index n and
-    grid cell index (i,j). The values for RHO is
-    calculated for the combination ((i,j), n) and this covers
-    one grid layer in ertbox grid or a 2D surface grid.
-
-    Args:
-        nx: Number of grid cells in x-direction of local coordinate system.
-        ny: Number of grid cells in y-direction of local coordinate system.
-        xinc: Grid cell size in x-direction.
-        yinc: Grid cell size in y-direction.
-        obs_xpos: Observations x coordinates in local coordinates
-        obs_ypos: Observatiopns y coordinates in local coordinates
-        obs_main_range: Localization ellipse first range
-        obs_perp_range: Localization ellipse second range
-        obs_anisotropy_angle: Localization ellipse orientation relative
-        to local coordinate system in degrees
-
-    Returns:
-        Rho matrix values for one layer of the 3D ertbox grid or for a 2D surface grid.
-    """
-    # Center points of each grid cell in field parameter grid
-    x_local = (np.arange(nx, dtype=np.float64) + 0.5) * xinc
-    if right_handed_grid_indexing:
-        # y coordinate descreases from max to min
-        y_local = (np.arange(ny - 1, -1, -1, dtype=np.float64) + 0.5) * yinc
-    else:
-        # y coordinate increases from min to max
-        y_local = (np.arange(ny, dtype=np.float64) + 0.5) * yinc
-    mesh_x_coord, mesh_y_coord = np.meshgrid(x_local, y_local, indexing="ij")
-
-    # Number of observations
-    nobs = len(obs_xpos)
-    assert nobs == len(obs_ypos), (
-        "Number of coordinates must match number of observations"
-    )
-    assert nobs == len(obs_anisotropy_angle), (
-        "Number of ellipse orientation angles must match number of observations"
-    )
-    assert nobs == len(obs_main_range), (
-        "Number of ellipse main range values must match number of observations"
-    )
-    assert nobs == len(obs_perp_range), (
-        "Number of ellipse second range values must match number of observations"
-    )
-    assert np.all(obs_main_range > 0.0), (
-        "All range values for all observations must be positive"
-    )
-    assert np.all(obs_perp_range > 0.0), (
-        "All range values for all observations must be positive"
-    )
-
-    # Expand grid coordinates to match observations
-    mesh_x_coord_flat = mesh_x_coord.flatten()[:, np.newaxis]  # (nx * ny, 1)
-    mesh_y_coord_flat = mesh_y_coord.flatten()[:, np.newaxis]  # (nx * ny, 1)
-
-    # Observation coordinates and parameters
-    obs_xpos = obs_xpos[np.newaxis, :]  # (1, nobs)
-    obs_ypos = obs_ypos[np.newaxis, :]  # (1, nobs)
-    obs_main_range = obs_main_range[np.newaxis, :]  # (1, nobs)
-    obs_perp_range = obs_perp_range[np.newaxis, :]  # (1, nobs)
-    obs_anisotropy_angle = obs_anisotropy_angle[np.newaxis, :]  # (1, nobs)
-
-    # Compute displacement between grid points and observations
-    dX = mesh_x_coord_flat - obs_xpos  # (nx * ny, nobs)
-    dY = mesh_y_coord_flat - obs_ypos  # (nx * ny, nobs)
-
-    # Compute rotation parameters
-    rotation = np.deg2rad(obs_anisotropy_angle)
-    cos_angle = np.cos(rotation)  # (1, nobs)
-    sin_angle = np.sin(rotation)  # (1, nobs)
-
-    # Rotate and scale displacements to local coordinate system defined
-    # by the two half axes of the influence ellipse. First coordinate (local x) is in
-    # direction defined by anisotropy angle and local y is perpendicular to that.
-    # Scale the distance by the ranges to get a normalized distance
-    # (with value 1 at the edge of the ellipse)
-    dX_ellipse = (dX * cos_angle + dY * sin_angle) / obs_main_range  # (nx * ny, nobs)
-    dY_ellipse = (-dX * sin_angle + dY * cos_angle) / obs_perp_range  # (nx * ny, nobs)
-
-    # Compute distances in the elliptical coordinate system
-    distances = np.hypot(dX_ellipse, dY_ellipse)  # (nx * ny, nobs)
-    # Apply the scaling function
-    return localization_scaling_function(distances).reshape((nx, ny, nobs))

ert/gui/ertwidgets/listeditbox.py

@@ -14,6 +14,7 @@ from PyQt6.QtWidgets import (
 )
 from typing_extensions import override
 
+from .. import is_dark_mode
 from .validationsupport import ValidationSupport
 
 
@@ -164,7 +165,14 @@ class ListEditBox(QWidget):
                     break
 
         validity_type = ValidationSupport.WARNING
-        color = ValidationSupport.ERROR_COLOR if not valid else self._valid_color
+        if is_dark_mode():
+            color = (
+                ValidationSupport.DARKMODE_ERROR_COLOR
+                if not valid
+                else self._valid_color
+            )
+        else:
+            color = ValidationSupport.ERROR_COLOR if not valid else self._valid_color
         self._validation_support.setValidationMessage(message, validity_type)
         self._list_edit_line.setToolTip(message)
         palette.setColor(self._list_edit_line.backgroundRole(), color)

ert/gui/ertwidgets/models/ertsummary.py

@@ -1,4 +1,4 @@
-from collections import defaultdict
+from collections import Counter, defaultdict
 
 from typing_extensions import TypedDict
 
@@ -38,8 +38,22 @@ class ErtSummary:
         return sorted(parameters, key=lambda k: k.lower()), count
 
     def getObservations(self) -> list[ObservationCount]:
-        counts: list[ObservationCount] = []
-        for df in self.ert_config.observations.values():
-            counts.extend(df.group_by("observation_key").len(name="count").to_dicts())  # type: ignore
-
-        return sorted(counts, key=lambda k: k["observation_key"].lower())
+        name_to_types = defaultdict(set)
+        for obs in self.ert_config.observation_declarations:
+            name_to_types[obs.name].add(obs.type)
+
+        multi_type_names = {
+            name for name, types in name_to_types.items() if len(types) > 1
+        }
+
+        keys = (
+            f"{obs.name}[{obs.type}]" if obs.name in multi_type_names else obs.name
+            for obs in self.ert_config.observation_declarations
+        )
+        counts = Counter(keys)
+
+        counts_list = [
+            ObservationCount({"observation_key": key, "count": count})
+            for key, count in counts.items()
+        ]
+        return sorted(counts_list, key=lambda k: k["observation_key"].lower())

ert/gui/ertwidgets/pathchooser.py

@@ -8,6 +8,7 @@ from PyQt6.QtCore import QSize
 from PyQt6.QtGui import QIcon
 from PyQt6.QtWidgets import QFileDialog, QHBoxLayout, QLineEdit, QToolButton, QWidget
 
+from .. import is_dark_mode
 from .validationsupport import ValidationSupport
 
 if TYPE_CHECKING:
@@ -107,7 +108,14 @@ class PathChooser(QWidget):
 
         validity_type = ValidationSupport.WARNING
 
-        color = ValidationSupport.ERROR_COLOR if not valid else self.valid_color
+        if is_dark_mode():
+            color = (
+                ValidationSupport.DARKMODE_ERROR_COLOR
+                if not valid
+                else self.valid_color
+            )
+        else:
+            color = ValidationSupport.ERROR_COLOR if not valid else self.valid_color
 
         self._validation_support.setValidationMessage(message, validity_type)
         self._path_line.setToolTip(message)

ert/gui/ertwidgets/stringbox.py

@@ -6,6 +6,7 @@ from PyQt6.QtGui import QPalette
 from PyQt6.QtWidgets import QLineEdit
 from typing_extensions import override
 
+from .. import is_dark_mode
 from .validationsupport import ValidationSupport
 
 if TYPE_CHECKING:
@@ -65,9 +66,16 @@ class StringBox(QLineEdit):
 
                 palette = QPalette()
                 if not status:
-                    palette.setColor(
-                        self.backgroundRole(), ValidationSupport.ERROR_COLOR
-                    )
+                    if is_dark_mode():
+                        palette.setColor(
+                            self.backgroundRole(),
+                            ValidationSupport.DARKMODE_ERROR_COLOR,
+                        )
+                    else:
+                        palette.setColor(
+                            self.backgroundRole(),
+                            ValidationSupport.ERROR_COLOR,
+                        )
                     self.setPalette(palette)
                     self._validation.setValidationMessage(
                         str(status), ValidationSupport.EXCLAMATION

ert/gui/ertwidgets/textbox.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any
 from PyQt6.QtGui import QPalette
 from PyQt6.QtWidgets import QTextEdit
 
+from .. import is_dark_mode
 from .validationsupport import ValidationSupport
 
 if TYPE_CHECKING:
@@ -51,9 +52,15 @@ class TextBox(QTextEdit):
 
                 palette = QPalette()
                 if not status:
-                    palette.setColor(
-                        self.backgroundRole(), ValidationSupport.ERROR_COLOR
-                    )
+                    if is_dark_mode():
+                        palette.setColor(
+                            self.backgroundRole(),
+                            ValidationSupport.DARKMODE_ERROR_COLOR,
+                        )
+                    else:
+                        palette.setColor(
+                            self.backgroundRole(), ValidationSupport.ERROR_COLOR
+                        )
                     self.setPalette(palette)
                     self._validation.setValidationMessage(
                         str(status), ValidationSupport.EXCLAMATION

ert/gui/ertwidgets/validationsupport.py

@@ -8,6 +8,8 @@ from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtGui import QColor, QEnterEvent
 from PyQt6.QtWidgets import QFrame, QLabel, QSizePolicy, QVBoxLayout, QWidget
 
+from ert.gui import is_dark_mode
+
 if TYPE_CHECKING:
     from PyQt6.QtCore import QEvent
     from PyQt6.QtGui import QHideEvent
@@ -23,6 +25,15 @@ class ErrorPopup(QWidget):
         "</html>"
     )
 
+    darkmode_error_template = (
+        "<html>"
+        "<table style='background-color: #b03941;'width='100%%'>"
+        "<tr><td style='font-weight: bold; padding-left: 0px;'>Warning:</td></tr>"
+        "%s"
+        "</table>"
+        "</html>"
+    )
+
     def __init__(self) -> None:
         QWidget.__init__(self, None, Qt.WindowType.ToolTip)
         self.resize(300, 50)
@@ -46,7 +57,13 @@ class ErrorPopup(QWidget):
     def presentError(self, widget: QWidget, error: str) -> None:
         assert isinstance(widget, QWidget)
 
-        self._error_widget.setText(ErrorPopup.error_template % html.escape(error))
+        if is_dark_mode():
+            self._error_widget.setText(
+                self.darkmode_error_template % html.escape(error)
+            )
+        else:
+            self._error_widget.setText(self.error_template % html.escape(error))
+
         self.show()
 
         size_hint = self.sizeHint()
@@ -63,6 +80,7 @@ class ErrorPopup(QWidget):
 class ValidationSupport(QObject):
     STRONG_ERROR_COLOR = QColor(255, 215, 215)
     ERROR_COLOR = QColor(255, 235, 235)
+    DARKMODE_ERROR_COLOR = QColor(176, 57, 64)
     INVALID_COLOR = QColor(235, 235, 255)
 
     WARNING = "warning"

ert/gui/main_window.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime
 import functools
 import logging
 import webbrowser
@@ -116,8 +115,10 @@ class ErtMainWindow(QMainWindow):
 
         if is_dark_mode():
             self.side_frame.setStyleSheet("background-color: rgb(64, 64, 64);")
+            logger.info("Running Ert with dark mode")
         else:
             self.side_frame.setStyleSheet("background-color: lightgray;")
+            logger.info("Running Ert with light mode")
 
         if is_high_contrast_mode():
             msg_box = QMessageBox()
@@ -233,15 +234,17 @@ class ErtMainWindow(QMainWindow):
             widget.setVisible(False)
 
         run_dialog.setParent(self)
-        date_time: str = datetime.datetime.now(datetime.UTC).isoformat(
-            timespec="seconds"
-        )
-        experiment_type = run_dialog._run_model_api.experiment_name
-        simulation_id = experiment_type + " : " + date_time
+        simulation_id = run_dialog.property("experiment_name")
         self.central_panels_map[simulation_id] = run_dialog
         self.run_dialog_counter += 1
         self.central_layout.addWidget(run_dialog)
 
+        def mark_action_bold(menu: QMenu, action_to_mark: QAction) -> None:
+            for action in menu.actions():
+                font = action.font()
+                font.setBold(action is action_to_mark)
+                action.setFont(font)
+
         def add_sim_run_option(simulation_id: str) -> None:
             menu = self.results_button.menu()
             if menu:
@@ -249,11 +252,13 @@ class ErtMainWindow(QMainWindow):
                 act = QAction(text=simulation_id, parent=menu)
                 act.setProperty("index", simulation_id)
                 act.triggered.connect(self.select_central_widget)
+                act.triggered.connect(lambda _: mark_action_bold(menu, act))
 
                 if action_list:
                     menu.insertAction(action_list[0], act)
                 else:
                     menu.addAction(act)
+                mark_action_bold(menu, menu.actions()[0])
 
         if self.run_dialog_counter == 2:
             # swap from button to menu selection

ert/gui/simulation/experiment_panel.py

@@ -184,7 +184,7 @@ class ExperimentPanel(QWidget):
 
         experiment_type_valid = any(
             p.update for p in config.ensemble_config.parameter_configs.values()
-        ) and bool(config.observations)
+        ) and bool(config.observation_declarations)
 
         self.addExperimentConfigPanel(
             MultipleDataAssimilationPanel(

ert/gui/simulation/run_dialog.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from datetime import datetime
+from datetime import UTC, datetime
 from pathlib import Path
 from queue import SimpleQueue
 from typing import cast
@@ -244,6 +244,15 @@ class RunDialog(QFrame):
             self,
         )
 
+        date_time: str = datetime.now(UTC).isoformat(timespec="seconds")
+        experiment_type = self._run_model_api.experiment_name
+        simulation_id = experiment_type + " : " + date_time
+
+        self._experiment_name_label = QLabel(self)
+        self._experiment_name_label.setText(simulation_id)
+        self._experiment_name_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.setProperty("experiment_name", simulation_id)
+
         self._total_progress_bar = QProgressBar(self)
         self._total_progress_bar.setRange(0, 100)
         self._total_progress_bar.setTextVisible(False)
@@ -325,6 +334,7 @@ class RunDialog(QFrame):
         footer_widget_container.setLayout(footer_layout)
 
         layout = QVBoxLayout()
+        layout.addWidget(self._experiment_name_label)
         layout.addWidget(self._total_progress_label)
         layout.addWidget(self._total_progress_bar)
         layout.addWidget(self._iteration_progress_label)

ert/gui/tools/manage_experiments/export_dialog.py

@@ -1,4 +1,5 @@
 import contextlib
+import logging
 from pathlib import Path
 from typing import cast
 
@@ -22,6 +23,8 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class ExportDialog(QDialog):
     """Base dialog for exporting ensemble-related data to files."""
@@ -85,6 +88,7 @@ class ExportDialog(QDialog):
                 f"<span style='color: red;'>Could not export data: {e!s}</span><br>"
             )
         finally:
+            logger.info(f"Export dialog used: '{self.windowTitle()}'")
             self._export_button.setEnabled(True)
 
     @Slot()

ert/gui/tools/manage_experiments/manage_experiments_panel.py

@@ -123,6 +123,7 @@ class ManageExperimentsPanel(QTabWidget):
                     active_realizations=active_realizations,
                     parameters=parameters,
                     random_seed=self.ert_config.random_seed,
+                    num_realizations=self.ert_config.runpath_config.num_realizations,
                     design_matrix_df=(
                         self.ert_config.analysis_config.design_matrix.design_matrix_df
                         if self.ert_config.analysis_config.design_matrix

ert/gui/tools/manage_experiments/storage_info_widget.py

@@ -7,6 +7,7 @@ import seaborn as sns
 import yaml
 from matplotlib.backends.backend_qt5agg import FigureCanvas  # type: ignore
 from matplotlib.figure import Figure
+from pandas.errors import PerformanceWarning
 from polars import DataFrame
 from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSlot as Slot
@@ -29,6 +30,7 @@ from PyQt6.QtWidgets import (
 
 from ert import LibresFacade
 from ert.storage import Ensemble, Experiment, RealizationStorageState
+from ert.warnings import capture_specific_warning
 
 from .export_dialog import ExportDialog
 
@@ -253,8 +255,8 @@ class _EnsembleWidget(QWidget):
                 df[x_axis_col]
                 .map_elements(
                     lambda x: response_config.display_column(x, x_axis_col),
-                    return_dtype=pl.String,
                 )
+                .cast(pl.String)
                 .alias("temp")
             ).filter(pl.col("temp").eq(observation_label))[
                 [x for x in df.columns if x != "temp"]
@@ -446,7 +448,8 @@ class _EnsembleWidget(QWidget):
 
     def get_misfit_df(self) -> DataFrame:
         assert self._ensemble is not None
-        df = LibresFacade.load_all_misfit_data(self._ensemble)
+        with capture_specific_warning(PerformanceWarning):
+            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)

ert/gui/tools/manage_experiments/storage_widget.py

@@ -22,7 +22,8 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ert.config import ErrorInfo, ErtConfig
+from ert.config import ErrorInfo, ErtConfig, RFTConfig
+from ert.config._create_observation_dataframes import create_observation_dataframes
 from ert.gui.ertnotifier import ErtNotifier
 from ert.gui.ertwidgets import CreateExperimentDialog, Suggestor
 from ert.storage import Ensemble, Experiment
@@ -169,10 +170,24 @@ class StorageWidget(QWidget):
         if create_experiment_dialog.exec():
             try:
                 with self._notifier.write_storage() as storage:
+                    response_configs = (
+                        self._ert_config.ensemble_config.response_configuration
+                    )
+
+                    rft_config = next(
+                        (r for r in response_configs if r.type == "rft"),
+                        None,
+                    )
+                    if rft_config is not None:
+                        rft_config = cast(RFTConfig, rft_config)
+
                     ensemble = storage.create_experiment(
                         parameters=self._ert_config.parameter_configurations_with_design_matrix,
-                        responses=self._ert_config.ensemble_config.response_configuration,
-                        observations=self._ert_config.observations,
+                        responses=response_configs,
+                        observations=create_observation_dataframes(
+                            observations=self._ert_config.observation_declarations,
+                            rft_config=rft_config,
+                        ),
                         name=create_experiment_dialog.experiment_name,
                         templates=self._ert_config.ert_templates,
                     ).create_ensemble(

ert/gui/tools/plot/data_type_proxy_model.py

@@ -42,7 +42,7 @@ class DataTypeProxyModel(QSortFilterProxyModel):
                         show = False
 
             # Filter out non-finalized responses
-            if key.response_metadata and not key.response_metadata.finalized:
+            if key.response and not key.response.has_finalized_keys:
                 show = False
 
         return show