Seismic cross plot

src/ert/gui/plotting/ert_plots/__init__.py

@@ -1,4 +1,5 @@
 from .cesp import CrossEnsembleStatisticsPlot
+from .cross import CrossPlot
 from .distribution import DistributionPlot
 from .gaussian_kde import GaussianKDEPlot
 from .histogram import HistogramPlot
@@ -8,6 +9,7 @@
 
 __all__ = [
     "CrossEnsembleStatisticsPlot",
+    "CrossPlot",
     "DistributionPlot",
     "GaussianKDEPlot",
     "HistogramPlot",

src/ert/gui/plotting/ert_plots/cross.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+
+from ert.gui.plotting.plot_api import EnsembleObject, PlotApiKeyDefinition
+from ert.gui.plotting.utils.plot_tools import ConditionalAxisFormatter, PlotTools
+from ert.gui.utils import truncate_experiment_name
+
+if TYPE_CHECKING:
+    import numpy.typing as npt
+    from matplotlib.axes import Axes
+    from matplotlib.figure import Figure
+
+    from ert.gui.plotting.utils import PlotConfig, PlotContext
+    from ert.gui.plotting.utils.plot_types import ObservationPlotLocations
+
+
+class CrossPlot:
+    def __init__(self) -> None:
+        self.dimensionality = 2
+        self.requires_observations = True
+
+    @staticmethod
+    def plot(
+        figure: Figure,
+        plot_context: PlotContext,
+        ensemble_to_data_map: dict[EnsembleObject, pd.DataFrame],
+        observation_data: pd.DataFrame,
+        std_dev_images: dict[str, npt.NDArray[np.float32]],
+        obs_loc: ObservationPlotLocations | None,
+        key_def: PlotApiKeyDefinition | None = None,
+    ) -> None:
+        plotCross(figure, plot_context, ensemble_to_data_map, observation_data)
+
+
+def plotCross(
+    figure: Figure,
+    plot_context: PlotContext,
+    ensemble_to_data_map: dict[EnsembleObject, pd.DataFrame],
+    observation_data: pd.DataFrame,
+) -> None:
+    config = plot_context.plotConfig()
+    axes = figure.add_subplot(111)
+
+    plot_context.x_axis = plot_context.VALUE_AXIS
+    plot_context.y_axis = plot_context.VALUE_AXIS
+    plot_context.deactivate_date_support()
+
+    if observation_data.empty:
+        axes.text(0.5, 0.5, "No observations available", ha="center", va="center")
+        axes.set_axis_off()
+        return
+
+    obs_by_key_index = _observations_by_key_index(observation_data)
+
+    all_obs: list[np.ndarray] = []
+    all_resp: list[np.ndarray] = []
+
+    for (ensemble, data), color_index in zip(
+        ensemble_to_data_map.items(),
+        plot_context.ensembles_color_indexes(),
+        strict=False,
+    ):
+        config.set_current_color(color_index)
+
+        if data.empty:
+            continue
+
+        obs_values, resp_values = _match_obs_to_responses(data, obs_by_key_index)
+        if obs_values.size == 0:
+            continue
+
+        label = (
+            f"{truncate_experiment_name(ensemble.experiment_name)} : {ensemble.name}"
+        )
+        _plot_cross(axes, config, obs_values, resp_values, label)
+
+        all_obs.append(obs_values)
+        all_resp.append(resp_values)
+
+    if all_obs:
+        _plot_identity_line(
+            axes, config, np.concatenate(all_obs), np.concatenate(all_resp)
+        )
+
+    axes.xaxis.set_major_formatter(ConditionalAxisFormatter())
+    axes.yaxis.set_major_formatter(ConditionalAxisFormatter())
+
+    if plot_context.log_scale:
+        axes.set_xscale("log")
+        axes.set_yscale("log")
+
+    PlotTools.finalize_plot(
+        plot_context,
+        figure,
+        axes,
+        default_x_label="Observation",
+        default_y_label="Response",
+    )
+
+
+def _observations_by_key_index(observation_data: pd.DataFrame) -> pd.Series:
+    obs_values = pd.to_numeric(
+        observation_data.loc["OBS"].to_numpy(), errors="coerce"
+    ).astype(np.float32)
+    raw_key_index = observation_data.loc["key_index"].to_numpy()
+    key_index = _to_matchable_key(raw_key_index)
+    series = pd.Series(obs_values, index=key_index)
+    return series[~series.index.duplicated(keep="first")].dropna()
+
+
+def _match_obs_to_responses(
+    ensemble_data: pd.DataFrame, obs_by_key_index: pd.Series
+) -> tuple[np.ndarray, np.ndarray]:
+    responses = ensemble_data.copy()
+    responses.columns = _to_matchable_key(responses.columns.to_numpy())
+
+    common_keys = obs_by_key_index.index.intersection(responses.columns)
+    if len(common_keys) == 0:
+        return np.array([], dtype=np.float32), np.array([], dtype=np.float32)
+
+    obs_matched = obs_by_key_index.loc[common_keys].to_numpy()
+    resp_matched = (
+        responses[common_keys]
+        .apply(pd.to_numeric, errors="coerce")
+        .to_numpy()
+        .astype(np.float32)
+    )
+
+    n_realizations = resp_matched.shape[0]
+    obs_flat = np.tile(obs_matched, n_realizations)
+    resp_flat = resp_matched.reshape(-1)
+
+    mask = ~np.isnan(obs_flat) & ~np.isnan(resp_flat)
+    return obs_flat[mask], resp_flat[mask]
+
+
+def _to_matchable_key(values: np.ndarray) -> np.ndarray:
+    numeric = pd.to_numeric(pd.Series(values), errors="coerce")
+    if numeric.notna().all():
+        return numeric.astype(np.float32).to_numpy()
+    return pd.Index(values).astype(str).to_numpy()
+
+
+def _plot_cross(
+    axes: Axes,
+    plot_config: PlotConfig,
+    obs_values: np.ndarray,
+    resp_values: np.ndarray,
+    label: str,
+) -> None:
+    style = plot_config.distribution_style()
+
+    lines = axes.plot(
+        obs_values,
+        resp_values,
+        color=style.color,
+        alpha=style.alpha,
+        marker=style.marker or "o",
+        markersize=style.size,
+        linestyle="",
+        label=label,
+    )
+
+    if lines:
+        plot_config.add_legend_item(label, lines[0])
+
+
+def _plot_identity_line(
+    axes: Axes,
+    plot_config: PlotConfig,
+    obs_values: np.ndarray,
+    resp_values: np.ndarray,
+) -> None:
+    lo = float(min(obs_values.min(), resp_values.min()))
+    hi = float(max(obs_values.max(), resp_values.max()))
+    if not np.isfinite(lo) or not np.isfinite(hi) or lo == hi:
+        return
+
+    lines = axes.plot(
+        [lo, hi],
+        [lo, hi],
+        color="red",
+        linestyle="-",
+        linewidth=1,
+        zorder=0,
+    )
+    if lines:
+        plot_config.add_legend_item("y = x", lines[0])

src/ert/gui/plotting/plot_api.py

@@ -46,6 +46,7 @@ class EnsembleObject:
     started_at: str
     has_func_eval: bool = False
     has_gradient: bool = False
+    size: int = 0
 
 
 class PlotApiKeyDefinition(NamedTuple):
@@ -133,6 +134,7 @@ def get_all_ensembles(self) -> list[EnsembleObject]:
                                 has_gradient=bool(
                                     response_json["userdata"].get("has_gradient", False)
                                 ),
+                                size=int(response_json.get("size", 0) or 0),
                             )
                         )
             except IndexError as exc:

src/ert/gui/plotting/plot_window.py

@@ -31,6 +31,7 @@
 from ert.gui.ertwidgets import CopyButton, showWaitCursorWhileWaiting
 from ert.gui.plotting.utils.plot_maps import (
     CROSS_ENSEMBLE_STATISTICS,
+    CROSSPLOT,
     DISTRIBUTION,
     ENSEMBLE,
     ERT_PLOT_MAP,
@@ -70,6 +71,7 @@
     StatisticsOptions,
 )
 from .widgets.plot_ensemble_selection_widget import EnsembleSelectionWidget
+from .widgets.plot_realization_selection_widget import RealizationSelectionWidget
 from .widgets.plot_widget import Plotter, PlotWidget
 
 EVEREST_UPPER_BATCH_LIMIT = 20
@@ -298,6 +300,19 @@ def __init__(
                 expanded=True,
             )
 
+            max_realizations = max((ens.size for ens in plot_case_objects), default=0)
+            self._realization_selection_widget = RealizationSelectionWidget(
+                [str(i) for i in range(max_realizations)]
+            )
+            self._realization_selection_widget.realizationSelectionChanged.connect(
+                self.update_plot
+            )
+            self._realization_group = CollapsibleSection(
+                "Select realization",
+                create_group_layout([self._realization_selection_widget]),
+                expanded=True,
+            )
+
             self._everest_controls_plot_options = EverestControlsPlotOptions(
                 self.update_plot
             )
@@ -317,6 +332,7 @@ def __init__(
                     self._general_options.get_widget(),
                     self._everest_controls_plot_options.get_widget(),
                     self._everest_controls_group,
+                    self._realization_group,
                     self._boxplot_options.get_widget(),
                     self._statistics_options.get_widget(),
                 ]
@@ -327,6 +343,7 @@ def __init__(
 
             self._everest_controls_group.setVisible(False)
             self._everest_controls_plot_options.get_widget().setVisible(False)
+            self._realization_group.setVisible(False)
             self._boxplot_options.get_widget().setVisible(False)
             self._statistics_options.get_widget().setVisible(False)
             self._data_type_keys_widget.selectDefault()
@@ -418,6 +435,7 @@ def update_plot(self, layer: int | None = None) -> None:
         )
         self._statistics_options.get_widget().setVisible(plot_widget.name == STATISTICS)
         self._general_options.get_widget().setVisible(plot_widget.name != STD_DEV)
+        self._realization_group.setVisible(plot_widget.name == CROSSPLOT)
 
         is_gradient_plot = plot_widget.name == EVEREST_GRADIENTS_PLOT
         is_controls_plot = plot_widget.name == EVEREST_CONTROLS_PLOT
@@ -515,6 +533,15 @@ def fetch_data(
                     elif result is not None:
                         ensemble_to_data_map[ensemble] = result
 
+            if plot_widget.name == CROSSPLOT:
+                selected_realization = (
+                    self._realization_selection_widget.get_selected_realization()
+                )
+                if selected_realization is not None:
+                    for ensemble, data in list(ensemble_to_data_map.items()):
+                        mask = data.index.astype(str) == selected_realization
+                        ensemble_to_data_map[ensemble] = data.loc[mask]
+
             log_scale_valid_values = True
             if key_def.parameter is not None and key_def.parameter.type == "gen_kw":
                 for data in ensemble_to_data_map.values():
@@ -775,7 +802,8 @@ def keySelected(self) -> None:
             if widget._plotter.dimensionality == key_def.dimensionality
             and (key_def.observations or not widget._plotter.requires_observations)
             and not is_everest_specific_widget
-            and (not is_observed_seismic or widget.name == MISFITS)
+            and (not is_observed_seismic or widget.name in {MISFITS, CROSSPLOT})
+            and (widget.name != CROSSPLOT or is_observed_seismic)
         ]
 
         def everest_data_origin_check(origin: list[str]) -> bool:

src/ert/gui/plotting/utils/plot_maps.py

@@ -2,6 +2,7 @@
 
 from ert.gui.plotting.ert_plots import (
     CrossEnsembleStatisticsPlot,
+    CrossPlot,
     DistributionPlot,
     GaussianKDEPlot,
     HistogramPlot,
@@ -27,6 +28,7 @@
 STATISTICS = "Statistics"
 STD_DEV = "Std dev"
 MISFITS = "Misfits"
+CROSSPLOT = "Cross plot"
 EVEREST_CONTROLS_PLOT = "Controls"
 EVEREST_GRADIENTS_PLOT = "Gradient"
 EVEREST_OBJECTIVE_FUNCTION_PLOT = "Objective function"
@@ -41,6 +43,7 @@
     DISTRIBUTION: DistributionPlot,
     CROSS_ENSEMBLE_STATISTICS: CrossEnsembleStatisticsPlot,
     STD_DEV: StdDevPlot,
+    CROSSPLOT: CrossPlot,
 }
 EVEREST_PLOT_MAP: dict[str, Callable[[], Plotter]] = {
     EVEREST_BATCH_OBJECTIVE_FUNCTION_PLOT: EverestBatchObjectiveFunctionPlot,

src/ert/gui/plotting/widgets/plot_realization_selection_widget.py

@@ -0,0 +1,51 @@
+from PyQt6.QtCore import pyqtSignal as Signal
+from PyQt6.QtWidgets import (
+    QAbstractItemView,
+    QListWidget,
+    QListWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class RealizationSelectionWidget(QWidget):
+    realizationSelectionChanged = Signal()
+
+    def __init__(
+        self,
+        realizations: list[str],
+    ) -> None:
+        super().__init__()
+        self._realizations_list = QListWidget()
+        self._realizations_list.setSelectionMode(
+            QAbstractItemView.SelectionMode.SingleSelection
+        )
+        self._realizations_list.itemSelectionChanged.connect(self._onSelectionChanged)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self._realizations_list)
+        layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(layout)
+
+        self.set_realizations(realizations)
+
+    def set_realizations(self, realizations: list[str]) -> None:
+        self._realizations_list.clear()
+        for realization in realizations:
+            item = QListWidgetItem(realization)
+            self._realizations_list.addItem(item)
+
+        if self._realizations_list.count() > 0:
+            first_item = self._realizations_list.item(0)
+            if first_item is not None:
+                first_item.setSelected(True)
+                self._realizations_list.setCurrentItem(first_item)
+
+    def get_selected_realization(self) -> str | None:
+        selected_realization = self._realizations_list.currentItem()
+        if selected_realization:
+            return selected_realization.text()
+        return None
+
+    def _onSelectionChanged(self) -> None:
+        self.realizationSelectionChanged.emit()

tests/ert/ui_tests/gui/test_main_window.py

@@ -356,6 +356,7 @@ def test_that_the_plot_window_contains_the_expected_elements(
             "Statistics",
             "Std dev",
             "Misfits",
+            "Cross plot",
         }
 
         model = data_keys.model()