Add simple statistics interface

The statistics customization tab disappeared with the plot
customization dialog, leaving no way to choose which statistics to
show. Reintroduce the controls in the plot sidebar, letting the user
select statistics and whether bands are filled.

Author: MagnusSletten

src/ert/gui/plotting/plot_window.py

@@ -58,13 +58,13 @@
 from .utils.plot_color_palettes import TABLEAU_10_COLOR_CYCLE
 from .utils.plot_types import ObservationPlotLocations
 from .utils.qt_creator import create_group_box, create_group_layout, create_side_panel
-from .utils.statistics_style import DEFAULT_ENABLED_STATISTICS
 from .widgets.data_type_keys_widget import DataTypeKeysWidget
 from .widgets.everest_control_selection_widget import EverestControlSelectionWidget
 from .widgets.plot_controls import (
     BoxplotOptions,
     EverestControlsPlotOptions,
     GeneralPlotOptions,
+    StatisticsOptions,
 )
 from .widgets.plot_ensemble_selection_widget import EnsembleSelectionWidget
 from .widgets.plot_widget import Plotter, PlotWidget
@@ -301,6 +301,7 @@ def __init__(
             self._general_options.axisLabelEditRequested.connect(self._edit_axis_label)
             self._general_options.titleEditRequested.connect(self._edit_title)
             self._boxplot_options = BoxplotOptions(self.update_plot)
+            self._statistics_options = StatisticsOptions(self.update_plot)
 
             right_container = QWidget()
             right_layout = create_group_layout(
@@ -310,13 +311,15 @@ def __init__(
                     self._everest_controls_plot_options.get_widget(),
                     self._everest_controls_group,
                     self._boxplot_options.get_widget(),
+                    self._statistics_options.get_widget(),
                 ]
             )
             right_container.setLayout(right_layout)
 
             self._everest_controls_group.setVisible(False)
             self._everest_controls_plot_options.get_widget().setVisible(False)
             self._boxplot_options.get_widget().setVisible(False)
+            self._statistics_options.get_widget().setVisible(False)
             self._data_type_keys_widget.selectDefault()
 
             splitter = QSplitter(Qt.Orientation.Horizontal)
@@ -384,6 +387,7 @@ def update_plot(self, layer: int | None = None) -> None:
         self._boxplot_options.get_widget().setVisible(
             plot_widget.name in {MISFITS, CROSS_ENSEMBLE_STATISTICS}
         )
+        self._statistics_options.get_widget().setVisible(plot_widget.name == STATISTICS)
         self._general_options.get_widget().setVisible(plot_widget.name != STD_DEV)
 
         is_gradient_plot = plot_widget.name == EVEREST_GRADIENTS_PLOT
@@ -543,9 +547,7 @@ def fetch_data(
             plot_config.set_x_label(self._x_labels.get(key_def.key))
             plot_config.set_y_label(self._y_labels.get(key_def.key))
             if selected_tab == STATISTICS:
-                plot_config.set_statistics_options(
-                    DEFAULT_ENABLED_STATISTICS, fill_bands=False
-                )
+                self._statistics_options.apply_to(plot_config)
             plot_config.set_legend_enabled(self._general_options.legend_checkbox_state)
             plot_config.set_grid_enabled(self._general_options.grid_checkbox_state)
             plot_config.set_line_color_cycle(self._general_options.get_color_cycle())

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

@@ -5,7 +5,10 @@
 from PyQt6.QtWidgets import (
     QCheckBox,
     QGroupBox,
+    QHBoxLayout,
     QLabel,
+    QSpinBox,
+    QToolButton,
     QVBoxLayout,
     QWidget,
 )
@@ -42,6 +45,44 @@ def create_group_box(title: str, layout: QVBoxLayout) -> QGroupBox:
     return group_box
 
 
+def create_collapsible_group_box(
+    title: str, layout: QVBoxLayout, name: str, *, expanded: bool = True
+) -> QGroupBox:
+    """Create a group box whose contents can be folded away by its header.
+
+    Collapsing only hides the contents; the widgets keep their values.
+    """
+    content = QWidget()
+    content.setObjectName(f"{name}_content")
+    content.setLayout(layout)
+    content.setVisible(expanded)
+
+    header = QToolButton()
+    header.setObjectName(f"{name}_header")
+    header.setText(title)
+    header.setCheckable(True)
+    header.setChecked(expanded)
+    header.setAutoRaise(True)
+    header.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
+    header.setArrowType(Qt.ArrowType.DownArrow if expanded else Qt.ArrowType.RightArrow)
+    header.setStyleSheet("QToolButton { border: none; font-style: italic; }")
+
+    def toggle_contents(checked: bool) -> None:
+        header.setArrowType(
+            Qt.ArrowType.DownArrow if checked else Qt.ArrowType.RightArrow
+        )
+        content.setVisible(checked)
+
+    header.toggled.connect(toggle_contents)
+
+    outer_layout = QVBoxLayout()
+    outer_layout.setContentsMargins(0, 0, 0, 0)
+    outer_layout.addWidget(header)
+    outer_layout.addWidget(content)
+
+    return create_group_box("", outer_layout)
+
+
 def create_checkbox_with_tooltip(
     name: str,
     tooltip: str,
@@ -57,3 +98,33 @@ def create_checkbox_with_tooltip(
     checkbox.stateChanged.connect(connection_point)
     log_plot_option_usage_once(checkbox.clicked, logger, name)
     return checkbox
+
+
+def create_spinbox_with_tooltip(
+    name: str,
+    tooltip: str,
+    connection_point: Callable[..., object],
+    *,
+    minimum: int,
+    maximum: int,
+    initial_value: int,
+    logger: Logger,
+) -> QSpinBox:
+    spinbox = QSpinBox()
+    spinbox.setObjectName(f"{name.lower().replace(' ', '_')}_spinbox")
+    spinbox.setToolTip(tooltip)
+    spinbox.setRange(minimum, maximum)
+    spinbox.setValue(initial_value)
+    spinbox.valueChanged.connect(connection_point)
+    log_plot_option_usage_once(spinbox.valueChanged, logger, name)
+    return spinbox
+
+
+def create_labeled_row(label: str, widget: QWidget) -> QWidget:
+    row = QWidget()
+    layout = QHBoxLayout(row)
+    layout.setContentsMargins(0, 0, 0, 0)
+    layout.addWidget(QLabel(label))
+    layout.addWidget(widget)
+    layout.addStretch()
+    return row

src/ert/gui/plotting/widgets/plot_controls/__init__.py

@@ -3,11 +3,13 @@
 from .everest_controls_plot_options import EverestControlsPlotOptions
 from .general_options import GeneralPlotOptions
 from .plot_color_palette_selector import PlotColorPaletteSelector
+from .statistics_options import StatisticsOptions
 
 __all__ = [
     "BoxplotOptions",
     "CustomPaletteDialog",
     "EverestControlsPlotOptions",
     "GeneralPlotOptions",
     "PlotColorPaletteSelector",
+    "StatisticsOptions",
 ]

src/ert/gui/plotting/widgets/plot_controls/statistics_options.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from PyQt6.QtWidgets import QGroupBox
+
+from ert.gui.plotting.utils.qt_creator import (
+    create_checkbox_with_tooltip,
+    create_collapsible_group_box,
+    create_group_layout,
+    create_labeled_row,
+    create_spinbox_with_tooltip,
+)
+from ert.gui.plotting.utils.statistics_style import (
+    BAND_STATISTICS,
+    DEFAULT_ENABLED_STATISTICS,
+    STATISTIC_LABELS,
+)
+
+if TYPE_CHECKING:
+    from ert.gui.plotting.utils import PlotConfig
+
+logger = logging.getLogger(__name__)
+
+
+class StatisticsOptions:
+    """Owns the statistics selection, which persists across keys."""
+
+    def __init__(self, connection_point: Callable[..., object]) -> None:
+        self._toggles = {
+            statistic: create_checkbox_with_tooltip(
+                label,
+                f"Show or hide the {label} "
+                + ("band" if statistic in BAND_STATISTICS else "line"),
+                connection_point,
+                initial_checked=statistic in DEFAULT_ENABLED_STATISTICS,
+                logger=logger,
+            )
+            for statistic, label in STATISTIC_LABELS.items()
+        }
+        self._area_toggle = create_checkbox_with_tooltip(
+            "Area",
+            "Draw the standard deviation, min/max and percentile ranges as a "
+            "filled area instead of a pair of lines",
+            connection_point,
+            initial_checked=False,
+            logger=logger,
+        )
+        self._std_dev_factor = create_spinbox_with_tooltip(
+            "Std dev multiplier",
+            "Choose the number of standard deviations to plot",
+            connection_point,
+            minimum=1,
+            maximum=3,
+            initial_value=1,
+            logger=logger,
+        )
+
+        self._statistics_options = create_collapsible_group_box(
+            "Statistics options",
+            create_group_layout(
+                [
+                    *self._toggles.values(),
+                    self._area_toggle,
+                    create_labeled_row("Std dev multiplier", self._std_dev_factor),
+                ]
+            ),
+            "statistics_options",
+        )
+
+    def apply_to(self, plot_config: PlotConfig) -> None:
+        plot_config.set_standard_deviation_factor(self._std_dev_factor.value())
+        plot_config.set_statistics_options(
+            self._enabled_statistics(),
+            fill_bands=self._area_toggle.isChecked(),
+        )
+
+    def _enabled_statistics(self) -> set[str]:
+        return {
+            statistic
+            for statistic, checkbox in self._toggles.items()
+            if checkbox.isChecked()
+        }
+
+    def get_widget(self) -> QGroupBox:
+        return self._statistics_options

tests/ert/unit_tests/gui/plotting/widgets/test_statistics_options.py

@@ -0,0 +1,113 @@
+from unittest.mock import Mock
+
+from PyQt6.QtWidgets import QToolButton, QWidget
+
+from ert.gui.plotting.utils import PlotConfig
+from ert.gui.plotting.utils.statistics_style import STATISTIC_LABELS
+from ert.gui.plotting.widgets.plot_controls.statistics_options import StatisticsOptions
+
+
+def _header_and_content(options: StatisticsOptions) -> tuple[QToolButton, QWidget]:
+    group_box = options.get_widget()
+    header = group_box.findChild(QToolButton, "statistics_options_header")
+    content = group_box.findChild(QWidget, "statistics_options_content")
+    assert header is not None
+    assert content is not None
+    return header, content
+
+
+def test_that_statistics_options_group_starts_expanded(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+    header, content = _header_and_content(options)
+
+    assert header.isChecked()
+    assert content.isVisibleTo(options.get_widget())
+
+
+def test_that_collapsing_statistics_options_hides_its_contents(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+    header, content = _header_and_content(options)
+
+    header.setChecked(False)
+    assert not content.isVisibleTo(options.get_widget())
+
+    header.setChecked(True)
+    assert content.isVisibleTo(options.get_widget())
+
+
+def test_that_statistics_options_have_expected_default_toggle_states(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+
+    checked = {
+        statistic
+        for statistic, checkbox in options._toggles.items()
+        if checkbox.isChecked()
+    }
+
+    assert checked == {"mean", "p10-p90"}
+    assert not options._area_toggle.isChecked()
+    assert options._std_dev_factor.value() == 1
+
+
+def test_that_unchecked_statistics_are_hidden_in_the_plot_config(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+    plot_config = PlotConfig()
+
+    options.apply_to(plot_config)
+
+    for statistic in STATISTIC_LABELS:
+        style = plot_config.get_statistics_style(statistic)
+        if statistic in {"mean", "p10-p90"}:
+            assert style.is_visible()
+        else:
+            assert not style.is_visible()
+
+
+def test_that_enabling_area_switches_band_statistics_to_a_filled_style(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+
+    line_config = PlotConfig()
+    options.apply_to(line_config)
+    assert line_config.get_statistics_style("p10-p90").line_style == "--"
+
+    options._area_toggle.setChecked(True)
+    area_config = PlotConfig()
+    options.apply_to(area_config)
+    assert area_config.get_statistics_style("p10-p90").line_style == "#"
+
+
+def test_that_the_std_dev_multiplier_is_applied_to_the_plot_config(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+    options._std_dev_factor.setValue(3)
+    plot_config = PlotConfig()
+
+    options.apply_to(plot_config)
+
+    assert plot_config.get_standard_deviation_factor() == 3
+
+
+def test_that_toggling_a_statistic_invokes_the_connection_point(qtbot):
+    connection_point = Mock()
+    options = StatisticsOptions(connection_point)
+    qtbot.addWidget(options.get_widget())
+
+    options._toggles["p50"].setChecked(True)
+
+    connection_point.assert_called()
+
+
+def test_that_applying_options_does_not_invoke_the_connection_point(qtbot):
+    connection_point = Mock()
+    options = StatisticsOptions(connection_point)
+    qtbot.addWidget(options.get_widget())
+    connection_point.reset_mock()
+
+    options.apply_to(PlotConfig())
+
+    connection_point.assert_not_called()