Add simple statistics interface

Both settings only had controls in the removed customization dialog,
even though the plotters still read them from PlotConfig. Add them to
the sidebar so the statistics and distribution plots regain the
options they lost.

Author: MagnusSletten

src/ert/gui/plotting/plot_window.py

@@ -45,6 +45,7 @@
     HISTOGRAM,
     MISFITS,
     SHARED_PLOT_MAP,
+    STATISTICS,
     STD_DEV,
 )
 from ert.gui.utils import is_everest_application
@@ -61,8 +62,10 @@
 from .widgets.everest_control_selection_widget import EverestControlSelectionWidget
 from .widgets.plot_controls import (
     BoxplotOptions,
+    DistributionOptions,
     EverestControlsPlotOptions,
     GeneralPlotOptions,
+    StatisticsOptions,
 )
 from .widgets.plot_ensemble_selection_widget import EnsembleSelectionWidget
 from .widgets.plot_widget import Plotter, PlotWidget
@@ -299,6 +302,8 @@ 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)
+            self._distribution_options = DistributionOptions(self.update_plot)
 
             right_container = QWidget()
             right_layout = create_group_layout(
@@ -308,13 +313,17 @@ def __init__(
                     self._everest_controls_plot_options.get_widget(),
                     self._everest_controls_group,
                     self._boxplot_options.get_widget(),
+                    self._statistics_options.get_widget(),
+                    self._distribution_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._distribution_options.get_widget().setVisible(False)
             self._data_type_keys_widget.selectDefault()
 
             splitter = QSplitter(Qt.Orientation.Horizontal)
@@ -382,6 +391,10 @@ 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._distribution_options.get_widget().setVisible(
+            plot_widget.name == DISTRIBUTION
+        )
         self._general_options.get_widget().setVisible(plot_widget.name != STD_DEV)
 
         is_gradient_plot = plot_widget.name == EVEREST_GRADIENTS_PLOT
@@ -540,6 +553,8 @@ def fetch_data(
             plot_config.set_title(self._titles.get(key_def.key, key_def.key))
             plot_config.set_x_label(self._x_labels.get(key_def.key))
             plot_config.set_y_label(self._y_labels.get(key_def.key))
+            self._statistics_options.apply_to(plot_config)
+            self._distribution_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,48 @@ def create_group_box(title: str, layout: QVBoxLayout) -> QGroupBox:
     return group_box
 
 
+def create_collapsible_group_box(
+    title: str, layout: QVBoxLayout, *, expanded: bool = True
+) -> QGroupBox:
+    """Create a group box whose contents can be folded away by its header.
+
+    The header is a disclosure arrow rather than a check, so it does not read
+    as a switch that turns the section off. Collapsing only hides the
+    contents; the widgets keep their values.
+    """
+    name = title.lower().replace(" ", "_")
+
+    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 +102,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

@@ -1,13 +1,17 @@
 from .boxplot_options import BoxplotOptions
 from .custom_palette_dialog import CustomPaletteDialog
+from .distribution_options import DistributionOptions
 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",
+    "DistributionOptions",
     "EverestControlsPlotOptions",
     "GeneralPlotOptions",
     "PlotColorPaletteSelector",
+    "StatisticsOptions",
 ]

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

@@ -0,0 +1,42 @@
+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_group_box,
+    create_group_layout,
+)
+
+if TYPE_CHECKING:
+    from ert.gui.plotting.utils import PlotConfig
+
+logger = logging.getLogger(__name__)
+
+
+class DistributionOptions:
+    def __init__(self, connection_point: Callable[..., object]) -> None:
+        self._connection_lines_toggle = create_checkbox_with_tooltip(
+            "Connection lines",
+            "Draw lines between the realizations of neighbouring ensembles",
+            connection_point,
+            initial_checked=False,
+            logger=logger,
+        )
+
+        self._distribution_options = create_group_box(
+            "Distribution options",
+            create_group_layout([self._connection_lines_toggle]),
+        )
+
+    def apply_to(self, plot_config: PlotConfig) -> None:
+        plot_config.set_distribution_line_enabled(
+            self._connection_lines_toggle.isChecked()
+        )
+
+    def get_widget(self) -> QGroupBox:
+        return self._distribution_options

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

@@ -0,0 +1,95 @@
+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,
+)
+
+if TYPE_CHECKING:
+    from ert.gui.plotting.utils import PlotConfig
+
+logger = logging.getLogger(__name__)
+
+# (statistic, label, tooltip, checked by default)
+_STATISTICS = [
+    ("mean", "Mean", "Show or hide the mean", True),
+    ("p50", "P50", "Show or hide the P50 line", False),
+    ("std", "Std dev", "Show or hide the standard deviation band", False),
+    ("min-max", "Min/Max", "Show or hide the min/max band", False),
+    ("p10-p90", "P10-P90", "Show or hide the P10-P90 band", True),
+    ("p33-p67", "P33-P67", "Show or hide the P33-P67 band", False),
+]
+
+_BAND_STATISTICS = frozenset({"std", "min-max", "p10-p90", "p33-p67"})
+
+_AREA_LINE_STYLE = "#"
+_BAND_LINE_STYLE = "--"
+
+_LINE_STYLE_WHEN_ENABLED = {"mean": "-", "p50": "--"}
+
+
+class StatisticsOptions:
+    def __init__(self, connection_point: Callable[..., object]) -> None:
+        self._toggles = {
+            statistic: create_checkbox_with_tooltip(
+                label, tooltip, connection_point, initial_checked=checked, logger=logger
+            )
+            for statistic, label, tooltip, checked in _STATISTICS
+        }
+        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 which standard deviation 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),
+                ]
+            ),
+        )
+
+    def apply_to(self, plot_config: PlotConfig) -> None:
+        """Enable or disable each statistic according to its checkbox."""
+        plot_config.set_standard_deviation_factor(self._std_dev_factor.value())
+        fill_area = self._area_toggle.isChecked()
+        for statistic, checkbox in self._toggles.items():
+            style = plot_config.get_statistics_style(statistic)
+            if not checkbox.isChecked():
+                style.line_style = ""
+                style.marker = ""
+            elif statistic in _BAND_STATISTICS:
+                style.line_style = _AREA_LINE_STYLE if fill_area else _BAND_LINE_STYLE
+                style.marker = ""
+            elif not style.is_visible():
+                style.line_style = _LINE_STYLE_WHEN_ENABLED[statistic]
+                style.marker = ""
+            plot_config.set_statistics_style(statistic, style)
+
+    def get_widget(self) -> QGroupBox:
+        return self._statistics_options

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

@@ -0,0 +1,61 @@
+from unittest.mock import Mock
+
+from PyQt6.QtWidgets import QToolButton, QWidget
+
+from ert.gui.plotting.utils import PlotConfig
+from ert.gui.plotting.widgets.plot_controls.statistics_options import StatisticsOptions
+
+_STATISTIC_NAMES = ("mean", "p50", "std", "min-max", "p10-p90", "p33-p67")
+
+
+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_collapsing_statistics_options_leaves_the_plot_config_unchanged(qtbot):
+    options = StatisticsOptions(Mock())
+    qtbot.addWidget(options.get_widget())
+    header, _ = _header_and_content(options)
+
+    expanded_config = PlotConfig()
+    options.apply_to(expanded_config)
+
+    header.setChecked(False)
+    collapsed_config = PlotConfig()
+    options.apply_to(collapsed_config)
+
+    assert (
+        collapsed_config.get_standard_deviation_factor()
+        == expanded_config.get_standard_deviation_factor()
+    )
+    for statistic in _STATISTIC_NAMES:
+        assert (
+            collapsed_config.get_statistics_style(statistic).line_style
+            == expanded_config.get_statistics_style(statistic).line_style
+        )