ert 17.1.9__py3-none-any.whl → 18.0.1__py3-none-any.whl

ert/ensemble_evaluator/snapshot.py

@@ -12,6 +12,7 @@ from _ert.events import (
     EESnapshot,
     EESnapshotUpdate,
     EnsembleCancelled,
+    EnsembleEvaluationWarning,
     EnsembleEvent,
     EnsembleFailed,
     EnsembleStarted,
@@ -424,7 +425,8 @@ class EnsembleSnapshot:
 
         elif e_type in get_args(EnsembleEvent):
             event = cast(EnsembleEvent, event)
-            self._ensemble_state = _ENSEMBLE_TYPE_EVENT_TO_STATUS[type(event)]
+            if not isinstance(event, EnsembleEvaluationWarning):
+                self._ensemble_state = _ENSEMBLE_TYPE_EVENT_TO_STATUS[type(event)]
         elif type(event) is EESnapshotUpdate:
             self.merge_snapshot(EnsembleSnapshot.from_nested_dict(event.snapshot))
         elif type(event) is EESnapshot:

ert/ensemble_evaluator/state.py

@@ -7,6 +7,7 @@ COLOR_RUNNING: Final = (255, 255, 153)
 COLOR_UNKNOWN: Final = (128, 128, 128)
 COLOR_WAITING: Final = (164, 200, 255)
 COLOR_CANCELLED: Final = (235, 242, 246)
+COLOR_WARNING: Final = (255, 103, 0)
 
 ENSEMBLE_STATE_CANCELLED: Final = "Cancelled"
 ENSEMBLE_STATE_FAILED: Final = "Failed"

ert/field_utils/__init__.py

@@ -4,20 +4,28 @@ from .field_file_format import FieldFileFormat
 from .field_utils import (
     ErtboxParameters,
     Shape,
+    calc_rho_for_2d_grid_layer,
     calculate_ertbox_parameters,
     get_shape,
+    localization_scaling_function,
     read_field,
     read_mask,
     save_field,
+    transform_local_ellipse_angle_to_local_coords,
+    transform_positions_to_local_field_coordinates,
 )
 
 __all__ = [
     "ErtboxParameters",
     "FieldFileFormat",
     "Shape",
+    "calc_rho_for_2d_grid_layer",
     "calculate_ertbox_parameters",
     "get_shape",
+    "localization_scaling_function",
     "read_field",
     "read_mask",
     "save_field",
+    "transform_local_ellipse_angle_to_local_coords",
+    "transform_positions_to_local_field_coordinates",
 ]

ert/field_utils/field_utils.py

@@ -15,7 +15,7 @@ from .roff_io import export_roff, import_roff
 
 if TYPE_CHECKING:
     import numpy.typing as npt
-    import xtgeo  # type: ignore
+    import xtgeo
 
 _PathLike: TypeAlias = str | os.PathLike[str]
 
@@ -262,3 +262,213 @@ def save_field(
         export_grdecl(field, output_path, field_name, binary=True)
     else:
         raise ValueError(f"Cannot export, invalid file format: {file_format}")
+
+
+def transform_positions_to_local_field_coordinates(
+    coordsys_origin: tuple[float, float],
+    coordsys_rotation_angle: float,
+    utmx: npt.NDArray[np.float64],
+    utmy: npt.NDArray[np.float64],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """Calculates coordinate transformation from global to local coordinates.
+
+    Args:
+        coordys_origin: (x,y) coordinate of local coordinate
+        origin in global coordinates.
+        coordsys_rotation_angle: Angle for how much the local x-axis is rotated
+        anti-clockwise relative to the global x-axis in degrees.
+        utmx: vector of x-coordinates in global coordinates.
+        utmy: vector of y-coordinates in global coordinates.
+
+    Returns:
+        First vector is local x-coordinates and second vector is local y-coordinates.
+    """
+    # Translate
+    x1 = utmx - coordsys_origin[0]
+    y1 = utmy - coordsys_origin[1]
+    # Rotate
+    # Input angle is the local coordinate systems rotation
+    # anticlockwise relative to global x-axis in degrees
+    rotation_of_ertbox = coordsys_rotation_angle
+    rotation_angle = np.deg2rad(rotation_of_ertbox)
+    cos_theta = np.cos(rotation_angle)
+    sin_theta = np.sin(rotation_angle)
+    x2 = x1 * cos_theta + y1 * sin_theta
+    y2 = -x1 * sin_theta + y1 * cos_theta
+    return x2, y2
+
+
+def transform_local_ellipse_angle_to_local_coords(
+    coordsys_rotation_angle: float,
+    ellipse_anisotropy_angle: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate angles relative to local coordinate system.
+
+    Args:
+        coordsys_rotation_angle: Local coordinate systems rotation angle
+        relative to the global coordinate system.
+        ellipse_anisotropy_angle: Vector of input angles in global coordinates.
+
+    Returns:
+        Vector of output angles relative to the local coordinate system.
+    """
+    # Both angles measured anti-clock from global coordinate systems x-axis in degrees
+    return ellipse_anisotropy_angle - coordsys_rotation_angle
+
+
+def localization_scaling_function(
+    distances: npt.NDArray[np.float64],
+) -> npt.NDArray[np.float64]:
+    """Calculate scaling factor to be used as values in
+    RHO matrix in distance-based localization.
+    The scaling function implements the commonly
+    used function published by Gaspari and Cohn.
+    For input normalized distance >= 2, the value will be 0.
+
+    Args:
+        distances: Vector of values for normalized distances.
+
+    Returns:
+        Values of scaling factors for each value of input distance.
+    """
+    # "gaspari-cohn"
+    # Commonly used in distance-based localization
+    # Is exact 0 for normalized distance > 2.
+    scaling_factor = distances
+    d2 = distances**2
+    d3 = d2 * distances
+    d4 = d3 * distances
+    d5 = d4 * distances
+    s = -1 / 4 * d5 + 1 / 2 * d4 + 5 / 8 * d3 - 5 / 3 * d2 + 1
+    scaling_factor[distances <= 1] = s[distances <= 1]
+    s = (
+        1 / 12 * d5
+        - 1 / 2 * d4
+        + 5 / 8 * d3
+        + 5 / 3 * d2
+        - 5 * distances
+        + 4
+        - 2 / 3 * 1 / distances
+    )
+    scaling_factor[(distances > 1) & (distances <= 2)] = s[
+        (distances > 1) & (distances <= 2)
+    ]
+    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/__init__.py

@@ -1,31 +1,34 @@
-# isort: skip_file
+from collections.abc import Callable
+from typing import Any
+
 from PyQt6.QtCore import Qt
 from PyQt6.QtGui import QCursor
 from PyQt6.QtWidgets import QApplication
-from typing import Any
-from collections.abc import Callable
-
 
-from .closabledialog import ClosableDialog
 from .analysismoduleedit import AnalysisModuleEdit
-from .searchbox import SearchBox
-from .ensembleselector import EnsembleSelector
 from .checklist import CheckList
-from .stringbox import StringBox
-from .textbox import TextBox
-from .listeditbox import ListEditBox
+from .closabledialog import ClosableDialog
+from .copy_button import CopyButton
+from .copyablelabel import CopyableLabel
+from .create_experiment_dialog import CreateExperimentDialog
 from .customdialog import CustomDialog
-from .pathchooser import PathChooser
+from .ensembleselector import EnsembleSelector
+from .listeditbox import ListEditBox
 from .models import (
-    TextModel,
     ActiveRealizationsModel,
+    ErtSummary,
+    PathModel,
+    SelectableListModel,
     TargetEnsembleModel,
+    TextModel,
     ValueModel,
-    SelectableListModel,
-    PathModel,
 )
-from .copyablelabel import CopyableLabel
-from .copy_button import CopyButton
+from .parameterviewer import get_parameters_button
+from .pathchooser import PathChooser
+from .searchbox import SearchBox
+from .stringbox import StringBox
+from .suggestor import Suggestor
+from .textbox import TextBox
 
 
 def showWaitCursorWhileWaiting(func: Callable[..., Any]) -> Callable[..., Any]:
@@ -49,17 +52,21 @@ __all__ = [
     "ClosableDialog",
     "CopyButton",
     "CopyableLabel",
+    "CreateExperimentDialog",
     "CustomDialog",
     "EnsembleSelector",
+    "ErtSummary",
     "ListEditBox",
     "PathChooser",
     "PathModel",
     "SearchBox",
     "SelectableListModel",
     "StringBox",
+    "Suggestor",
     "TargetEnsembleModel",
     "TextBox",
     "TextModel",
     "ValueModel",
+    "get_parameters_button",
     "showWaitCursorWhileWaiting",
 ]

ert/gui/ertwidgets/analysismoduleedit.py

@@ -6,8 +6,8 @@ from PyQt6.QtCore import QMargins, Qt
 from PyQt6.QtGui import QIcon
 from PyQt6.QtWidgets import QHBoxLayout, QToolButton, QWidget
 
-from ert.gui.ertwidgets import ClosableDialog
-from ert.gui.ertwidgets.analysismodulevariablespanel import AnalysisModuleVariablesPanel
+from .analysismodulevariablespanel import AnalysisModuleVariablesPanel
+from .closabledialog import ClosableDialog
 
 if TYPE_CHECKING:
     from ert.config import AnalysisModule

ert/gui/ertwidgets/checklist.py

@@ -16,7 +16,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ert.gui.ertwidgets import SearchBox
+from .searchbox import SearchBox
 
 if TYPE_CHECKING:
     from .models.selectable_list_model import SelectableListModel

ert/gui/ertwidgets/create_experiment_dialog.py

@@ -9,9 +9,11 @@ from PyQt6.QtWidgets import (
 )
 
 from ert.gui.ertnotifier import ErtNotifier
-from ert.gui.ertwidgets import StringBox, TextModel, ValueModel
 from ert.validation import ExperimentValidation, IntegerArgument, ProperNameArgument
 
+from .models import TextModel, ValueModel
+from .stringbox import StringBox
+
 
 class CreateExperimentDialog(QDialog):
     onDone = Signal(str, str, int)

ert/gui/ertwidgets/ensembleselector.py

@@ -9,11 +9,11 @@ from PyQt6.QtCore import Qt
 from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtWidgets import QComboBox
 
+from ert.config import ErrorInfo
 from ert.gui.ertnotifier import ErtNotifier
 from ert.storage import RealizationStorageState
 
-from ...config import ErrorInfo
-from ..suggestor import Suggestor
+from .suggestor import Suggestor
 
 if TYPE_CHECKING:
     from ert.storage import Ensemble

ert/gui/ertwidgets/models/__init__.py

@@ -1,4 +1,5 @@
 from .activerealizationsmodel import ActiveRealizationsModel
+from .ertsummary import ErtSummary
 from .path_model import PathModel
 from .selectable_list_model import SelectableListModel
 from .targetensemblemodel import TargetEnsembleModel
@@ -7,6 +8,7 @@ from .valuemodel import ValueModel
 
 __all__ = [
     "ActiveRealizationsModel",
+    "ErtSummary",
     "PathModel",
     "SelectableListModel",
     "TargetEnsembleModel",

ert/gui/ertwidgets/models/activerealizationsmodel.py

@@ -2,9 +2,10 @@ from collections.abc import Collection
 
 from typing_extensions import override
 
-from ert.gui.ertwidgets.models.valuemodel import ValueModel
 from ert.validation import ActiveRange, mask_to_rangestring
 
+from .valuemodel import ValueModel
+
 
 class ActiveRealizationsModel(ValueModel):
     def __init__(self, ensemble_size: int, show_default: bool = True) -> None:

ert/gui/ertwidgets/models/path_model.py

@@ -1,4 +1,4 @@
-from ert.gui.ertwidgets.models.valuemodel import ValueModel
+from .valuemodel import ValueModel
 
 
 class PathModel(ValueModel):

ert/gui/ertwidgets/models/targetensemblemodel.py

@@ -4,7 +4,8 @@ from typing_extensions import override
 
 from ert.config import AnalysisConfig
 from ert.gui.ertnotifier import ErtNotifier
-from ert.gui.ertwidgets.models.valuemodel import ValueModel
+
+from .valuemodel import ValueModel
 
 
 class TargetEnsembleModel(ValueModel):

ert/gui/ertwidgets/models/text_model.py

@@ -1,6 +1,6 @@
 from typing_extensions import override
 
-from ert.gui.ertwidgets.models.valuemodel import ValueModel
+from .valuemodel import ValueModel
 
 
 class TextModel(ValueModel):

ert/gui/ertwidgets/searchbox.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from PyQt6.QtCore import Qt
+from PyQt6.QtCore import Qt, QTimer
 from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtGui import QColor, QFocusEvent, QKeyEvent
 from PyQt6.QtWidgets import QLineEdit
@@ -12,16 +12,25 @@ class SearchBox(QLineEdit):
 
     filterChanged = Signal(object)
 
-    def __init__(self) -> None:
+    def __init__(self, debounce_timeout: int = 1000) -> None:
         QLineEdit.__init__(self)
 
         self.setToolTip("Type to search!")
         self.active_color = self.palette().color(self.foregroundRole())
         self.disable_search = True
         self.presentSearch()
-        self.textChanged.connect(self.__emitFilterChanged)
+        self.textChanged.connect(self._start_debounce_timer)
+        self._debounce_timout = debounce_timeout
+        self._debounce_timer = QTimer(self)
+        self._debounce_timer.setSingleShot(True)
+        self._debounce_timer.timeout.connect(self._emit_filter_changed)
 
-    def __emitFilterChanged(self, _filter: Any) -> None:
+    def _start_debounce_timer(self, _filter: Any) -> None:
+        if not self._debounce_timer.isActive():
+            self._debounce_timer.start(self._debounce_timout)
+        self._debounce_timer.setInterval(self._debounce_timout)
+
+    def _emit_filter_changed(self) -> None:
         self.filterChanged.emit(self.filter())
 
     def filter(self) -> str:

ert/gui/{suggestor → ertwidgets/suggestor}/_suggestor_message.py

@@ -13,10 +13,11 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from ert.gui import is_dark_mode
 
-from ..ertwidgets.copyablelabel import _CopyButton
+from ..copy_button import CopyButton
 from ._colors import (
     BLUE_BACKGROUND,
     BLUE_TEXT,
@@ -33,6 +34,16 @@ def _svg_icon(image_name: str) -> QSvgWidget:
     return widget
 
 
+class _CopyButton(CopyButton):
+    def __init__(self, message: str) -> None:
+        super().__init__()
+        self.message = message
+
+    @override
+    def copy(self) -> None:
+        self.copy_text(self.message)
+
+
 class SuggestorMessage(QWidget):
     def __init__(
         self,
@@ -100,9 +111,7 @@ class SuggestorMessage(QWidget):
         else:
             self._expand_collapse_label = QLabel()
             self._hbox.addWidget(self.lbl, alignment=Qt.AlignmentFlag.AlignTop)
-        self._hbox.addWidget(
-            _CopyButton(QLabel(message)), alignment=Qt.AlignmentFlag.AlignTop
-        )
+        self._hbox.addWidget(_CopyButton(message), alignment=Qt.AlignmentFlag.AlignTop)
 
     def _toggle_expand(self, _link: Any) -> None:
         if self._expanded:

ert/gui/main.py

@@ -8,6 +8,7 @@ import traceback
 import types
 from collections import Counter
 from importlib.resources import files
+from pathlib import Path
 from signal import SIG_DFL, SIGINT, signal
 
 from opentelemetry.trace import Status, StatusCode
@@ -27,11 +28,16 @@ from ert.gui.tools.event_viewer import (
 )
 from ert.namespace import Namespace
 from ert.plugins import ErtRuntimePlugins, get_site_plugins
-from ert.services import StorageService
-from ert.storage import ErtStorageException, local_storage_set_ert_config, open_storage
+from ert.services import ErtServer
+from ert.storage import (
+    ErtStorageException,
+    LocalStorage,
+    local_storage_set_ert_config,
+    open_storage,
+)
 from ert.trace import trace, tracer
 
-from .suggestor import Suggestor
+from .ertwidgets import Suggestor
 
 logger = logging.getLogger(__name__)
 
@@ -113,7 +119,7 @@ def run_gui(args: Namespace, plugins: ErtRuntimePlugins | None = None) -> int:
             return show_window()
 
         try:
-            with StorageService.init_service(project=os.path.abspath(ens_path)):
+            with ErtServer.init_service(project=Path(ens_path).absolute()):
                 return show_window()
         except PermissionError as pe:
             print(f"Error: {pe}", file=sys.stderr)
@@ -157,9 +163,10 @@ def _start_initial_gui_window(
     storage_path = None
     if ert_config is not None:
         try:
-            # Open write to initialize the storage,so that
-            # dark storage can be mounted onto it
-            open_storage(ert_config.ens_path, mode="w").close()
+            if LocalStorage.check_migration_needed(Path(ert_config.ens_path)):
+                # Open in write mode to initialize the storage, so that
+                # dark storage can be mounted onto it
+                open_storage(ert_config.ens_path, mode="w").close()
             storage_path = ert_config.ens_path
         except ErtStorageException as err:
             validation_messages.errors.append(

ert/gui/main_window.py

@@ -9,7 +9,7 @@ from pathlib import Path
 from PyQt6.QtCore import QCoreApplication, QEvent, QSize, Qt
 from PyQt6.QtCore import pyqtSignal as Signal
 from PyQt6.QtCore import pyqtSlot as Slot
-from PyQt6.QtGui import QAction, QCloseEvent, QCursor, QFontDatabase, QIcon, QMouseEvent
+from PyQt6.QtGui import QAction, QCloseEvent, QCursor, QIcon, QMouseEvent
 from PyQt6.QtWidgets import (
     QButtonGroup,
     QFrame,
@@ -96,7 +96,6 @@ class ErtMainWindow(QMainWindow):
         log_handler: GUILogHandler | None = None,
     ) -> None:
         QMainWindow.__init__(self)
-        self.available_fonts = QFontDatabase.families()
         self.notifier = ErtNotifier()
         self.plugins_tool: PluginsTool | None = None
         self.ert_config = ert_config

ert/gui/simulation/ensemble_experiment_panel.py

@@ -17,6 +17,7 @@ from ert.gui.ertwidgets import (
     CopyableLabel,
     StringBox,
     TextModel,
+    get_parameters_button,
 )
 from ert.mode_definitions import ENSEMBLE_EXPERIMENT_MODE
 from ert.run_models import EnsembleExperiment
@@ -24,7 +25,6 @@ from ert.validation import ExperimentValidation, ProperNameArgument
 from ert.validation.active_range import ActiveRange
 from ert.validation.range_string_argument import RangeSubsetStringArgument
 
-from ..ertwidgets.parameterviewer import get_parameters_button
 from ._design_matrix_panel import DesignMatrixPanel
 from .experiment_config_panel import ExperimentConfigPanel
 

ert/gui/simulation/ensemble_information_filter_panel.py

@@ -14,6 +14,7 @@ from ert.gui.ertwidgets import (
     StringBox,
     TargetEnsembleModel,
     TextModel,
+    get_parameters_button,
 )
 from ert.mode_definitions import ENIF_MODE
 from ert.run_models import EnsembleInformationFilter
@@ -24,7 +25,6 @@ from ert.validation import (
 from ert.validation.active_range import ActiveRange
 from ert.validation.range_string_argument import RangeSubsetStringArgument
 
-from ..ertwidgets.parameterviewer import get_parameters_button
 from ._design_matrix_panel import DesignMatrixPanel
 from .experiment_config_panel import ExperimentConfigPanel
 

ert/gui/simulation/ensemble_smoother_panel.py

@@ -16,6 +16,7 @@ from ert.gui.ertwidgets import (
     StringBox,
     TargetEnsembleModel,
     TextModel,
+    get_parameters_button,
 )
 from ert.mode_definitions import ENSEMBLE_SMOOTHER_MODE
 from ert.run_models import EnsembleSmoother
@@ -26,7 +27,6 @@ from ert.validation import (
 from ert.validation.active_range import ActiveRange
 from ert.validation.range_string_argument import RangeSubsetStringArgument
 
-from ..ertwidgets.parameterviewer import get_parameters_button
 from ._design_matrix_panel import DesignMatrixPanel
 from .experiment_config_panel import ExperimentConfigPanel
 

ert/gui/simulation/evaluate_ensemble_panel.py

@@ -14,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

ert/gui/simulation/experiment_panel.py

@@ -364,7 +364,7 @@ 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.set_queue_system_name(model.queue_config.queue_system)
         self.experiment_started.emit(self._dialog)
         self._simulation_done = False
         self.run_button.setEnabled(self._simulation_done)