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

ert/gui/tools/plot/plot_api.py

@@ -16,10 +16,12 @@ import numpy.typing as npt
 import pandas as pd
 from pandas.api.types import is_numeric_dtype
 from pandas.errors import ParserError
+from resfo_utilities import history_key
 
-from ert.config import ParameterMetadata, ResponseMetadata
-from ert.services import StorageService
-from ert.summary_key_type import history_key
+from ert.config import ParameterConfig, ResponseMetadata
+from ert.services import ErtServer
+from ert.storage.local_experiment import _parameters_adapter as parameter_config_adapter
+from ert.storage.realization_storage_state import RealizationStorageState
 
 logger = logging.getLogger(__name__)
 
@@ -43,7 +45,7 @@ class PlotApiKeyDefinition(NamedTuple):
     dimensionality: int
     metadata: dict[Any, Any]
     filter_on: dict[Any, Any] | None = None
-    parameter_metadata: ParameterMetadata | None = None
+    parameter: ParameterConfig | None = None
     response_metadata: ResponseMetadata | None = None
 
 
@@ -55,7 +57,7 @@ class PlotApi:
 
     @property
     def api_version(self) -> str:
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             try:
                 response = client.get("/version", timeout=self._timeout)
                 self._check_response(response)
@@ -81,7 +83,7 @@ class PlotApi:
             return self._all_ensembles
 
         self._all_ensembles = []
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             try:
                 response = client.get("/experiments", timeout=self._timeout)
                 self._check_response(response)
@@ -92,18 +94,27 @@ class PlotApi:
                             f"/ensembles/{ensemble_id}", timeout=self._timeout
                         )
                         self._check_response(response)
-                        response_json = response.json()
+                        response_json: dict[str, Any] = response.json()
                         ensemble_name: str = response_json["userdata"]["name"]
                         experiment_name: str = response_json["userdata"][
                             "experiment_name"
                         ]
                         ensemble_started_at = response_json["userdata"]["started_at"]
+                        ensemble_undefined = False
+                        if realization_storage_states := response_json.get(
+                            "realization_storage_states"
+                        ):
+                            ensemble_undefined = (
+                                RealizationStorageState.PARAMETERS_LOADED
+                                not in set(realization_storage_states)
+                            )
                         self._all_ensembles.append(
                             EnsembleObject(
                                 name=ensemble_name,
                                 id=ensemble_id,
                                 experiment_name=experiment_name,
-                                hidden=ensemble_name.startswith("."),
+                                hidden=ensemble_name.startswith(".")
+                                or ensemble_undefined,
                                 started_at=ensemble_started_at,
                             )
                         )
@@ -128,23 +139,26 @@ class PlotApi:
         all_keys: dict[str, PlotApiKeyDefinition] = {}
         all_params = {}
 
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get("/experiments", timeout=self._timeout)
             self._check_response(response)
 
             for experiment in response.json():
-                for param_metadatas in experiment["parameters"].values():
-                    for metadata in param_metadatas:
-                        param_key = metadata["key"]
-                        all_keys[param_key] = PlotApiKeyDefinition(
-                            key=param_key,
-                            index_type=None,
-                            observations=False,
-                            dimensionality=metadata["dimensionality"],
-                            metadata=metadata["userdata"],
-                            parameter_metadata=ParameterMetadata(**metadata),
-                        )
-                        all_params[param_key] = all_keys[param_key]
+                for metadata in experiment["parameters"].values():
+                    param_cfg = parameter_config_adapter.validate_python(metadata)
+                    if group := metadata.get("group"):
+                        param_key = f"{group}:{metadata['name']}"
+                    else:
+                        param_key = metadata["name"]
+                    all_keys[param_key] = PlotApiKeyDefinition(
+                        key=param_key,
+                        index_type=None,
+                        observations=False,
+                        dimensionality=metadata["dimensionality"],
+                        metadata={"data_origin": metadata["type"]},
+                        parameter=param_cfg,
+                    )
+                    all_params[param_key] = all_keys[param_key]
 
         return list(all_keys.values())
 
@@ -152,7 +166,7 @@ class PlotApi:
     def responses_api_key_defs(self) -> list[PlotApiKeyDefinition]:
         key_defs: dict[str, PlotApiKeyDefinition] = {}
 
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get("/experiments", timeout=self._timeout)
             self._check_response(response)
 
@@ -214,7 +228,7 @@ class PlotApi:
         response_key: str,
         filter_on: dict[str, Any] | None = None,
     ) -> pd.DataFrame:
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get(
                 f"/ensembles/{ensemble_id}/responses/{PlotApi.escape(response_key)}",
                 headers={"accept": "application/x-parquet"},
@@ -231,7 +245,10 @@ class PlotApi:
             try:
                 df.columns = pd.to_datetime(df.columns, format="%Y-%m-%d %H:%M:%S")
             except (ParserError, ValueError):
-                df.columns = [int(s) for s in df.columns]
+                try:
+                    df.columns = [int(s) for s in df.columns]
+                except ValueError:
+                    df.columns = [float(s) for s in df.columns]
 
             try:
                 return df.astype(float)
@@ -239,7 +256,7 @@ class PlotApi:
                 return df
 
     def data_for_parameter(self, ensemble_id: str, parameter_key: str) -> pd.DataFrame:
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             parameter = client.get(
                 f"/ensembles/{ensemble_id}/parameters/{PlotApi.escape(parameter_key)}",
                 headers={"accept": "application/x-parquet"},
@@ -281,7 +298,7 @@ class PlotApi:
             assert key_def.response_metadata is not None
             actual_response_key = key_def.response_metadata.response_key
             filter_on = key_def.filter_on
-            with StorageService.session(project=self.ens_path) as client:
+            with ErtServer.session(project=self.ens_path) as client:
                 response = client.get(
                     f"/ensembles/{ensemble.id}/responses/{PlotApi.escape(actual_response_key)}/observations",
                     timeout=self._timeout,
@@ -305,12 +322,17 @@ class PlotApi:
                         f"ensemble_name={ensemble.name}, e={e}"
                     ) from e
 
+                key_index: list[int | float | pd.Timestamp]
                 for obs in observations:
                     try:
                         int(obs["x_axis"][0])
                         key_index = [int(v) for v in obs["x_axis"]]
                     except ValueError:
-                        key_index = [pd.Timestamp(v) for v in obs["x_axis"]]
+                        try:
+                            float(obs["x_axis"][0])
+                            key_index = [float(v) for v in obs["x_axis"]]
+                        except ValueError:
+                            key_index = [pd.Timestamp(v) for v in obs["x_axis"]]
 
                     observations_dfs.append(
                         pd.DataFrame(
@@ -364,7 +386,7 @@ class PlotApi:
         if not ensemble:
             return np.array([])
 
-        with StorageService.session(project=self.ens_path) as client:
+        with ErtServer.session(project=self.ens_path) as client:
             response = client.get(
                 f"/ensembles/{ensemble.id}/parameters/{PlotApi.escape(key)}/std_dev",
                 params={"z": z},

ert/gui/tools/plot/plot_ensemble_selection_widget.py

@@ -28,6 +28,7 @@ from PyQt6.QtWidgets import (
     QVBoxLayout,
     QWidget,
 )
+from typing_extensions import override
 
 from .plot_api import EnsembleObject
 
@@ -39,22 +40,24 @@ class EnsembleSelectionWidget(QWidget):
         self, ensembles: list[EnsembleObject], number_of_plot_colors: int
     ) -> None:
         QWidget.__init__(self)
-        self.__dndlist = EnsembleSelectListWidget(ensembles, number_of_plot_colors)
-
-        self.__ensemble_layout = QVBoxLayout()
-        self.__ensemble_layout.setSpacing(0)
-        self.__ensemble_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
-        self.__ensemble_layout.addWidget(self.__dndlist)
-        self.setLayout(self.__ensemble_layout)
-        self.__dndlist.ensembleSelectionListChanged.connect(
+        self._selected_ensembles = EnsembleSelectListWidget(
+            ensembles, number_of_plot_colors
+        )
+
+        self._ensemble_layout = QVBoxLayout()
+        self._ensemble_layout.setSpacing(0)
+        self._ensemble_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
+        self._ensemble_layout.addWidget(self._selected_ensembles)
+        self.setLayout(self._ensemble_layout)
+        self._selected_ensembles.ensembleSelectionListChanged.connect(
             self.ensembleSelectionChanged.emit
         )
 
     def get_selected_ensembles(self) -> list[EnsembleObject]:
-        return self.__dndlist.get_checked_ensembles()
+        return self._selected_ensembles.get_checked_ensembles()
 
     def get_selected_ensembles_color_indexes(self) -> list[int]:
-        return self.__dndlist.get_checked_color_indexes()
+        return self._selected_ensembles.get_checked_color_indexes()
 
 
 class EnsembleSelectListWidgetItemDataRole(IntEnum):
@@ -121,6 +124,7 @@ class EnsembleSelectListWidget(QListWidget):
 
         return list(_iter())
 
+    @override
     def mouseMoveEvent(self, e: QMouseEvent | None) -> None:
         super().mouseMoveEvent(e)
         if e is not None and self.itemAt(e.pos()):
@@ -128,6 +132,7 @@ class EnsembleSelectListWidget(QListWidget):
         else:
             self.setCursor(QCursor(Qt.CursorShape.ArrowCursor))
 
+    @override
     def dropEvent(self, event: QDropEvent | None) -> None:
         super().dropEvent(event)
         self.ensembleSelectionListChanged.emit()
@@ -171,9 +176,11 @@ class CustomItemDelegate(QStyledItemDelegate):
         super().__init__()
         self.swap_pixmap = QIcon("img:reorder.svg").pixmap(QSize(20, 20))
 
+    @override
     def sizeHint(self, option: Any, index: Any) -> QSize:
         return QSize(-1, 30)
 
+    @override
     def paint(
         self, painter: QPainter | None, option: QStyleOptionViewItem, index: QModelIndex
     ) -> None:

ert/gui/tools/plot/plot_widget.py

@@ -23,8 +23,9 @@ from PyQt6.QtWidgets import (
     QWidget,
     QWidgetAction,
 )
+from typing_extensions import override
 
-from .plot_api import EnsembleObject
+from .plot_api import EnsembleObject, PlotApiKeyDefinition
 
 if TYPE_CHECKING:
     from .plottery import PlotContext
@@ -33,6 +34,7 @@ if TYPE_CHECKING:
     from .plottery.plots.ensemble import EnsemblePlot
     from .plottery.plots.gaussian_kde import GaussianKDEPlot
     from .plottery.plots.histogram import HistogramPlot
+    from .plottery.plots.misfits import MisfitsPlot
     from .plottery.plots.statistics import StatisticsPlot
     from .plottery.plots.std_dev import StdDevPlot
 
@@ -79,19 +81,23 @@ class CustomNavigationToolbar(NavigationToolbar2QT):
 
             action.triggered.connect(lambda _, a=action: self.logToolbarUsage(a.text()))
 
+    @override
     def logToolbarUsage(self, action_name: str) -> None:
         logger.info(f"Plotwindow toolbar used: {action_name}")
 
+    @override
     @Slot(bool)
     def showLayerWidget(self, show: bool) -> None:
         self._layer_action.setVisible(show)
 
+    @override
     @Slot()
     def resetLayerWidget(
         self,
     ) -> None:
         self._layer_action.defaultWidget().setCurrentIndex(0)
 
+    @override
     @Slot(int)
     def updateLayerWidget(self, layers: int) -> None:
         if layers != len(self._model.stringList()):
@@ -117,6 +123,7 @@ class PlotWidget(QWidget):
             "DistributionPlot",
             "CrossEnsembleStatisticsPlot",
             "StdDevPlot",
+            "MisfitsPlot",
         ],
         parent: QWidget | None = None,
     ) -> None:
@@ -168,7 +175,11 @@ class PlotWidget(QWidget):
         self._figure.clear()
 
     def _sync_log_checkbox(self) -> None:
-        if type(self._plotter).__name__ == "HistogramPlot":
+        if type(self._plotter).__name__ in {
+            "HistogramPlot",
+            "DistributionPlot",
+            "GaussianKDEPlot",
+        }:
             self._log_checkbox.setVisible(True)
         else:
             self._log_checkbox.setVisible(False)
@@ -183,6 +194,7 @@ class PlotWidget(QWidget):
         ensemble_to_data_map: dict[EnsembleObject, pd.DataFrame],
         observations: pd.DataFrame,
         std_dev_images: dict[str, npt.NDArray[np.float32]],
+        key_def: PlotApiKeyDefinition | None = None,
     ) -> None:
         self.resetPlot()
         try:
@@ -195,6 +207,7 @@ class PlotWidget(QWidget):
                 ensemble_to_data_map,
                 observations,
                 std_dev_images,
+                key_def,
             )
             self._canvas.draw()
             self._sync_log_checkbox()

ert/gui/tools/plot/plot_window.py

@@ -22,6 +22,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
+from ert.config.field import Field
 from ert.dark_storage.common import get_storage_api_version
 from ert.gui.ertwidgets import CopyButton, showWaitCursorWhileWaiting
 from ert.services._base_service import ServerBootFail
@@ -39,6 +40,7 @@ from .plottery.plots import (
     EnsemblePlot,
     GaussianKDEPlot,
     HistogramPlot,
+    MisfitsPlot,
     StatisticsPlot,
     StdDevPlot,
 )
@@ -50,10 +52,11 @@ ENSEMBLE = "Ensemble"
 HISTOGRAM = "Histogram"
 STATISTICS = "Statistics"
 STD_DEV = "Std Dev"
+MISFITS = "Misfits"
 
 RESPONSE_DEFAULT = 0
-GEN_KW_DEFAULT = 2
-STD_DEV_DEFAULT = 6
+GEN_KW_DEFAULT = 3
+STD_DEV_DEFAULT = 7
 
 
 logger = logging.getLogger(__name__)
@@ -188,6 +191,7 @@ class PlotWindow(QMainWindow):
 
             self.addPlotWidget(ENSEMBLE, EnsemblePlot())
             self.addPlotWidget(STATISTICS, StatisticsPlot())
+            self.addPlotWidget(MISFITS, MisfitsPlot())
             self.addPlotWidget(HISTOGRAM, HistogramPlot())
             self.addPlotWidget(GAUSSIAN_KDE, GaussianKDEPlot())
             self.addPlotWidget(DISTRIBUTION, DistributionPlot())
@@ -269,10 +273,13 @@ class PlotWindow(QMainWindow):
                             response_key=key_def.response_metadata.response_key,
                             filter_on=key_def.filter_on,
                         )
-                    elif key_def.parameter_metadata is not None:
+                    elif (
+                        key_def.parameter is not None
+                        and key_def.parameter.type == "gen_kw"
+                    ):
                         ensemble_to_data_map[ensemble] = self._api.data_for_parameter(
                             ensemble_id=ensemble.id,
-                            parameter_key=key_def.parameter_metadata.key,
+                            parameter_key=key_def.parameter.name,
                         )
                 except BaseException as e:
                     handle_exception(e)
@@ -287,10 +294,10 @@ class PlotWindow(QMainWindow):
                     handle_exception(e)
 
             std_dev_images: dict[str, npt.NDArray[np.float32]] = {}
-            if "FIELD" in key_def.metadata["data_origin"]:
-                plot_widget.showLayerWidget.emit(True)
 
-                layers = key_def.metadata["ertbox_params"]["nz"]
+            if isinstance(key_def.parameter, Field):
+                plot_widget.showLayerWidget.emit(True)
+                layers = key_def.parameter.ertbox_params.nz
                 plot_widget.updateLayerWidget.emit(layers)
 
                 if layer is None:
@@ -332,6 +339,18 @@ class PlotWindow(QMainWindow):
                     handle_exception(e)
                     plot_context.history_data = None
 
+            if (
+                key_def.response_metadata is not None
+                and key_def.response_metadata.response_type == "rft"
+            ):
+                plot_context.setXLabel(key.split(":")[-1])
+                plot_context.setYLabel("TVD")
+                plot_context.depth_y_axis = True
+                for ekey, data in list(ensemble_to_data_map.items()):
+                    ensemble_to_data_map[ekey] = data.interpolate(
+                        method="linear", axis="columns"
+                    )
+
             for data in ensemble_to_data_map.values():
                 data = data.T
 
@@ -342,7 +361,11 @@ class PlotWindow(QMainWindow):
             self._updateCustomizer(plot_widget, self._preferred_ensemble_x_axis_format)
 
             plot_widget.updatePlot(
-                plot_context, ensemble_to_data_map, observations, std_dev_images
+                plot_context,
+                ensemble_to_data_map,
+                observations,
+                std_dev_images,
+                key_def,
             )
 
     def _updateCustomizer(
@@ -371,15 +394,14 @@ class PlotWindow(QMainWindow):
     def addPlotWidget(
         self,
         name: str,
-        plotter: (
-            EnsemblePlot
-            | StatisticsPlot
-            | HistogramPlot
-            | GaussianKDEPlot
-            | DistributionPlot
-            | CrossEnsembleStatisticsPlot
-            | StdDevPlot
-        ),
+        plotter: EnsemblePlot
+        | StatisticsPlot
+        | HistogramPlot
+        | GaussianKDEPlot
+        | DistributionPlot
+        | CrossEnsembleStatisticsPlot
+        | StdDevPlot
+        | MisfitsPlot,
         enabled: bool = True,
     ) -> None:
         plot_widget = PlotWidget(name, plotter)
@@ -418,6 +440,7 @@ class PlotWindow(QMainWindow):
             widget
             for widget in self._plot_widgets
             if widget._plotter.dimensionality == key_def.dimensionality
+            and (key_def.observations or not widget._plotter.requires_observations)
         ]
 
         # Enabling/disabling tab triggers the
@@ -431,8 +454,6 @@ class PlotWindow(QMainWindow):
             self._central_tab.setTabEnabled(
                 self._central_tab.indexOf(plot_widget), plot_widget in available_widgets
             )
-        self._central_tab.currentChanged.connect(self.currentTabChanged)
-
         current_widget = self._central_tab.currentWidget()
 
         if 0 < self._prev_key_dimensionality != key_def.dimensionality:
@@ -447,6 +468,7 @@ class PlotWindow(QMainWindow):
             self._current_tab_index = -1
 
         self._central_tab.setCurrentWidget(current_widget)
+        self._central_tab.currentChanged.connect(self.currentTabChanged)
         self._prev_tab_widget_index = self._central_tab.currentIndex()
         self._prev_key_dimensionality = key_def.dimensionality
         self.updatePlot()

ert/gui/tools/plot/plottery/plot_config.py

@@ -88,6 +88,8 @@ class PlotConfig:
 
         self._std_dev_factor = 1  # sigma 1 is default std dev
 
+        self.depth_y_axis = False
+
     def getNumberOfColors(self) -> int:
         return len(self._line_color_cycle_colors)
 

ert/gui/tools/plot/plottery/plot_context.py

@@ -47,6 +47,14 @@ class PlotContext:
         self._y_axis: str | None = None
         self._log_scale = False
 
+    @property
+    def depth_y_axis(self) -> bool:
+        return self._plot_config.depth_y_axis
+
+    @depth_y_axis.setter
+    def depth_y_axis(self, value: bool) -> None:
+        self._plot_config.depth_y_axis = value
+
     def plotConfig(self) -> PlotConfig:
         return self._plot_config
 
@@ -93,6 +101,12 @@ class PlotContext:
             )
         self._y_axis = value
 
+    def setXLabel(self, value: str) -> None:
+        self._plot_config.setXLabel(value)
+
+    def setYLabel(self, value: str) -> None:
+        self._plot_config.setYLabel(value)
+
     @property
     def log_scale(self) -> bool:
         return self._log_scale

ert/gui/tools/plot/plottery/plots/__init__.py

@@ -3,6 +3,7 @@ from .distribution import DistributionPlot
 from .ensemble import EnsemblePlot
 from .gaussian_kde import GaussianKDEPlot
 from .histogram import HistogramPlot
+from .misfits import MisfitsPlot
 from .statistics import StatisticsPlot
 from .std_dev import StdDevPlot
 
@@ -12,6 +13,7 @@ __all__ = [
     "EnsemblePlot",
     "GaussianKDEPlot",
     "HistogramPlot",
+    "MisfitsPlot",
     "StatisticsPlot",
     "StdDevPlot",
 ]

ert/gui/tools/plot/plottery/plots/cesp.py

@@ -8,7 +8,7 @@ from matplotlib.lines import Line2D
 from matplotlib.patches import Rectangle
 from typing_extensions import TypedDict
 
-from ert.gui.tools.plot.plot_api import EnsembleObject
+from ert.gui.tools.plot.plot_api import EnsembleObject, PlotApiKeyDefinition
 
 from .plot_tools import ConditionalAxisFormatter, PlotTools
 
@@ -37,6 +37,7 @@ class CcsData(TypedDict):
 class CrossEnsembleStatisticsPlot:
     def __init__(self) -> None:
         self.dimensionality = 1
+        self.requires_observations = False
 
     @staticmethod
     def plot(
@@ -45,6 +46,7 @@ class CrossEnsembleStatisticsPlot:
         ensemble_to_data_map: dict[EnsembleObject, pd.DataFrame],
         observation_data: pd.DataFrame,
         std_dev_images: dict[str, npt.NDArray[np.float32]],
+        key_def: PlotApiKeyDefinition | None = None,
     ) -> None:
         plotCrossEnsembleStatistics(
             figure, plot_context, ensemble_to_data_map, observation_data

ert/gui/tools/plot/plottery/plots/distribution.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 import numpy as np
 import pandas as pd
 
-from ert.gui.tools.plot.plot_api import EnsembleObject
+from ert.gui.tools.plot.plot_api import EnsembleObject, PlotApiKeyDefinition
 
 from .plot_tools import ConditionalAxisFormatter, PlotTools
 
@@ -20,6 +20,7 @@ if TYPE_CHECKING:
 class DistributionPlot:
     def __init__(self) -> None:
         self.dimensionality = 1
+        self.requires_observations = False
 
     @staticmethod
     def plot(
@@ -28,6 +29,7 @@ class DistributionPlot:
         ensemble_to_data_map: dict[EnsembleObject, pd.DataFrame],
         observation_data: pd.DataFrame,
         std_dev_images: dict[str, npt.NDArray[np.float32]],
+        key_def: PlotApiKeyDefinition | None = None,
     ) -> None:
         plotDistribution(figure, plot_context, ensemble_to_data_map, observation_data)
 
@@ -80,6 +82,9 @@ def plotDistribution(
     )
     config.setLegendEnabled(False)
 
+    if plot_context.log_scale:
+        axes.set_yscale("log")
+
     PlotTools.finalizePlot(
         plot_context, figure, axes, default_x_label="Ensemble", default_y_label="Value"
     )

ert/gui/tools/plot/plottery/plots/ensemble.py

@@ -4,8 +4,7 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
-
-from ert.summary_key_type import is_rate
+from resfo_utilities import is_rate
 
 from .history import plotHistory
 from .observations import plotObservations
@@ -16,13 +15,14 @@ if TYPE_CHECKING:
     from matplotlib.axes import Axes
     from matplotlib.figure import Figure
 
-    from ert.gui.tools.plot.plot_api import EnsembleObject
+    from ert.gui.tools.plot.plot_api import EnsembleObject, PlotApiKeyDefinition
     from ert.gui.tools.plot.plottery import PlotConfig, PlotContext
 
 
 class EnsemblePlot:
     def __init__(self) -> None:
         self.dimensionality = 2
+        self.requires_observations = False
 
     def plot(
         self,
@@ -31,6 +31,7 @@ class EnsemblePlot:
         ensemble_to_data_map: dict[EnsembleObject, pd.DataFrame],
         observation_data: pd.DataFrame,
         std_dev_images: dict[str, npt.NDArray[np.float32]],
+        key_def: PlotApiKeyDefinition | None = None,
     ) -> None:
         config = plot_context.plotConfig()
         axes = figure.add_subplot(111)
@@ -87,9 +88,16 @@ class EnsemblePlot:
         if len(data) == 1 and not style.marker:
             style.marker = "."
 
+        if plot_config.depth_y_axis:
+            x = data.to_numpy()
+            y = data.index.to_numpy()
+            axes.yaxis.set_inverted(True)
+        else:
+            y = data.to_numpy()
+            x = data.index.to_numpy()
         lines = axes.plot(
-            data.index.to_numpy(),
-            data.to_numpy(),
+            x,
+            y,
             color=style.color,
             alpha=style.alpha,
             marker=style.marker,