webviz-subsurface 0.2.37__py3-none-any.whl → 0.2.38__py3-none-any.whl

webviz_subsurface/plugins/_co2_leakage/_utilities/co2volume.py

@@ -1,3 +1,5 @@
+# pylint: disable=too-many-lines
+# NBNB-AS: We should address this pylint message soon
 import warnings
 from datetime import datetime as dt
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -12,6 +14,9 @@ from webviz_subsurface._utils.enum_shim import StrEnum
 from webviz_subsurface.plugins._co2_leakage._utilities.containment_data_provider import (
     ContainmentDataProvider,
 )
+from webviz_subsurface.plugins._co2_leakage._utilities.containment_info import (
+    ContainmentInfo,
+)
 from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
     Co2MassScale,
     Co2VolumeScale,
@@ -29,6 +34,10 @@ _COLOR_TOTAL = "#222222"
 _COLOR_CONTAINED = "#00aa00"
 _COLOR_OUTSIDE = "#006ddd"
 _COLOR_HAZARDOUS = "#dd4300"
+_COLOR_DISSOLVED = "#208eb7"
+_COLOR_GAS = "#C41E3A"
+_COLOR_FREE = "#FF2400"
+_COLOR_TRAPPED = "#880808"
 _COLOR_ZONES = [
     "#e91451",
     "#daa218",
@@ -62,6 +71,9 @@ _LIGHTER_COLORS = {
     "#1357ca": "#7ba7f3",
     "#f75ef0": "#fbaef7",
     "#34b36f": "#93e0b7",
+    "#C41E3A": "#E42E5A",
+    "#FF2400": "#FF7430",
+    "#880808": "#C84848",
 }
 
 
@@ -80,6 +92,10 @@ def _read_dataframe(
 def _get_colors(num_cols: int = 3, split: str = "zone") -> List[str]:
     if split == "containment":
         return [_COLOR_HAZARDOUS, _COLOR_OUTSIDE, _COLOR_CONTAINED]
+    if split == "phase":
+        if num_cols == 2:
+            return [_COLOR_GAS, _COLOR_DISSOLVED]
+        return [_COLOR_FREE, _COLOR_TRAPPED, _COLOR_DISSOLVED]
     options = list(_COLOR_ZONES)
     if split == "region":
         options.reverse()
@@ -104,6 +120,7 @@ def _get_marks(num_marks: int, mark_choice: str) -> List[str]:
                 f"Some {mark_choice}s will share pattern."
             )
         return base_pattern[:num_marks]
+    # mark_choice == "phase":
     return ["", "/"] if num_marks == 2 else ["", ".", "/"]
 
 
@@ -113,35 +130,36 @@ def _get_line_types(mark_options: List[str], mark_choice: str) -> List[str]:
     if mark_choice == "containment":
         return ["dash", "dot", "solid"]
     if mark_choice in ["zone", "region", "plume_group"]:
-        if len(mark_options) > 8:
+        options = ["solid", "dash", "dot", "dashdot", "longdash", "longdashdot"]
+        if len(mark_options) > 6:
             warnings.warn(
                 f"Large number of {mark_choice}s might make it hard "
                 f"to distinguish different dashed lines."
             )
-        return [
-            f"{round(i / len(mark_options) * 25)}px" for i in range(len(mark_options))
-        ]
+        return [options[i % 6] for i in range(len(mark_options))]
+    # mark_choice == "phase":
     return ["dot", "dash"] if "gas" in mark_options else ["dot", "dashdot", "dash"]
 
 
 def _prepare_pattern_and_color_options(
     df: pd.DataFrame,
-    containment_info: Dict,
+    containment_info: ContainmentInfo,
     color_choice: str,
     mark_choice: str,
 ) -> Tuple[Dict, List, List]:
-    mark_options = [] if mark_choice == "none" else containment_info[f"{mark_choice}s"]
-    color_options = containment_info[f"{color_choice}s"]
+    no_mark = mark_choice == "none"
+    mark_options = [] if no_mark else getattr(containment_info, f"{mark_choice}s")
+    color_options = getattr(containment_info, f"{color_choice}s")
     num_colors = len(color_options)
-    num_marks = num_colors if mark_choice == "none" else len(mark_options)
+    num_marks = num_colors if no_mark else len(mark_options)
     marks = _get_marks(num_marks, mark_choice)
     colors = _get_colors(num_colors, color_choice)
-    if mark_choice == "none":
+    if no_mark:
         cat_ord = {"type": color_options}
         df["type"] = df[color_choice]
         return cat_ord, colors, marks
     df["type"] = [", ".join((c, m)) for c, m in zip(df[color_choice], df[mark_choice])]
-    if containment_info["sorting"] == "color":
+    if containment_info.sorting == "color":
         cat_ord = {
             "type": [", ".join((c, m)) for c in color_options for m in mark_options],
         }
@@ -158,14 +176,15 @@ def _prepare_pattern_and_color_options(
 
 def _prepare_pattern_and_color_options_statistics_plot(
     df: pd.DataFrame,
-    containment_info: Dict,
+    containment_info: ContainmentInfo,
     color_choice: str,
     mark_choice: str,
 ) -> Tuple[Dict, List, List]:
-    mark_options = [] if mark_choice == "none" else containment_info[f"{mark_choice}s"]
-    color_options = containment_info[f"{color_choice}s"]
+    no_mark = mark_choice == "none"
+    mark_options = [] if no_mark else getattr(containment_info, f"{mark_choice}s")
+    color_options = getattr(containment_info, f"{color_choice}s")
     num_colors = len(color_options)
-    num_marks = num_colors if mark_choice == "none" else len(mark_options)
+    num_marks = num_colors if no_mark else len(mark_options)
     line_types = _get_line_types(mark_options, mark_choice)
     colors = _get_colors(num_colors, color_choice)
 
@@ -173,7 +192,7 @@ def _prepare_pattern_and_color_options_statistics_plot(
         mark_options = ["total"] + mark_options
         line_types = ["solid"] + line_types
         num_marks += 1
-    if color_choice == "containment":
+    if color_choice in ["containment", "phase"]:
         color_options = ["total"] + color_options
         colors = ["black"] + colors
         num_colors += 1
@@ -182,13 +201,13 @@ def _prepare_pattern_and_color_options_statistics_plot(
     filter_color = color_choice not in ["phase", "containment"]
     _filter_rows(df, color_choice, mark_choice, filter_mark, filter_color)
 
-    if mark_choice == "none":
+    if no_mark:
         cat_ord = {"type": color_options}
         df["type"] = df[color_choice]
         return cat_ord, colors, line_types
     df["type"] = [", ".join((c, m)) for c, m in zip(df[color_choice], df[mark_choice])]
 
-    if containment_info["sorting"] == "color":
+    if containment_info.sorting == "color":
         cat_ord = {
             "type": [", ".join((c, m)) for c in color_options for m in mark_options],
         }
@@ -227,9 +246,7 @@ def _prepare_pattern_and_color_options_statistics_plot(
     return cat_ord, colors, line_types
 
 
-def _find_default_option_statistics_figure(
-    df: pd.DataFrame, categories: List[str]
-) -> str:
+def _find_default_legendonly(df: pd.DataFrame, categories: List[str]) -> List[str]:
     if "hazardous" in categories:
         default_option = "hazardous"
     else:
@@ -240,29 +257,32 @@ def _find_default_option_statistics_figure(
             if df_filtered["amount"].max() > max_value:
                 max_value = df_filtered["amount"].max()
                 default_option = category
-    return default_option
+
+    # The default list should contain all categories HIDDEN in the legend, so we need
+    # to create a copy of the list with default_option excluded instead.
+    return [c for c in categories if c != default_option]
 
 
 def _prepare_line_type_and_color_options(
     df: pd.DataFrame,
-    containment_info: Dict,
+    containment_info: ContainmentInfo,
     color_choice: str,
     mark_choice: str,
 ) -> pd.DataFrame:
     mark_options = []
     if mark_choice != "none":
-        mark_options = list(containment_info[f"{mark_choice}s"])
-    color_options = list(containment_info[f"{color_choice}s"])
+        mark_options = list(getattr(containment_info, f"{mark_choice}s"))
+    color_options = list(getattr(containment_info, f"{color_choice}s"))
     num_colors = len(color_options)
     line_types = _get_line_types(mark_options, mark_choice)
     colors = _get_colors(num_colors, color_choice)
 
     filter_mark = True
-    if mark_choice == "phase":
+    if mark_choice in ["containment", "phase"]:
         mark_options = ["total"] + mark_options
         line_types = ["solid"] + line_types
         filter_mark = False
-    if color_choice == "containment":
+    if color_choice in ["containment", "phase"]:
         color_options = ["total"] + color_options
         colors = ["black"] + colors
     else:
@@ -278,7 +298,7 @@ def _prepare_line_type_and_color_options(
         )
     df["name"] = [", ".join((c, m)) for c, m in zip(df[color_choice], df[mark_choice])]
     _change_names(df, color_options, mark_options)
-    if containment_info["sorting"] == "color":
+    if containment_info.sorting == "color":
         options = pd.DataFrame(
             {
                 "name": [
@@ -306,7 +326,7 @@ def _read_terminal_co2_volumes(
     table_provider: ContainmentDataProvider,
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
-    containment_info: Dict[str, Union[str, None, List[str]]],
+    containment_info: ContainmentInfo,
 ) -> pd.DataFrame:
     records: Dict[str, List[Any]] = {
         "real": [],
@@ -314,8 +334,8 @@ def _read_terminal_co2_volumes(
         "sort_key": [],
         "sort_key_secondary": [],
     }
-    color_choice = containment_info["color_choice"]
-    mark_choice = containment_info["mark_choice"]
+    color_choice = containment_info.color_choice
+    mark_choice = containment_info.mark_choice
     assert isinstance(color_choice, str)
     assert isinstance(mark_choice, str)
     records[color_choice] = []
@@ -324,7 +344,7 @@ def _read_terminal_co2_volumes(
     data_frame = None
     for real in realizations:
         df = table_provider.extract_dataframe(real, scale)
-        df = df[df["date"] == containment_info["date_option"]]
+        df = df[df["date"] == containment_info.date_option]
         _add_sort_key_and_real(df, str(real), containment_info)
         _filter_columns(df, color_choice, mark_choice, containment_info)
         _filter_rows(df, color_choice, mark_choice)
@@ -343,7 +363,7 @@ def _filter_columns(
     df: pd.DataFrame,
     color_choice: str,
     mark_choice: str,
-    containment_info: Dict,
+    containment_info: ContainmentInfo,
 ) -> None:
     filter_columns = [
         col
@@ -351,7 +371,7 @@ def _filter_columns(
         if col not in [mark_choice, color_choice]
     ]
     for col in filter_columns:
-        df.query(f'{col} == "{containment_info[col]}"', inplace=True)
+        df.query(f'{col} == "{getattr(containment_info, col)}"', inplace=True)
     df.drop(columns=filter_columns, inplace=True)
 
 
@@ -371,24 +391,24 @@ def _filter_rows(
 def _add_sort_key_and_real(
     df: pd.DataFrame,
     label: str,
-    containment_info: Dict,
+    containment_info: ContainmentInfo,
 ) -> None:
     sort_value = np.sum(
         df[
             (df["phase"] == "total")
             & (df["containment"] == "hazardous")
-            & (df["zone"] == containment_info["zone"])
-            & (df["region"] == containment_info["region"])
-            & (df["plume_group"] == containment_info["plume_group"])
+            & (df["zone"] == containment_info.zone)
+            & (df["region"] == containment_info.region)
+            & (df["plume_group"] == containment_info.plume_group)
         ]["amount"]
     )
     sort_value_secondary = np.sum(
         df[
             (df["phase"] == "total")
             & (df["containment"] == "outside")
-            & (df["zone"] == containment_info["zone"])
-            & (df["region"] == containment_info["region"])
-            & (df["plume_group"] == containment_info["plume_group"])
+            & (df["zone"] == containment_info.zone)
+            & (df["region"] == containment_info.region)
+            & (df["plume_group"] == containment_info.plume_group)
         ]["amount"]
     )
     df["real"] = [label] * df.shape[0]
@@ -422,19 +442,18 @@ def _change_names(
         df["name"] = df["name"].replace(f"{m}, all", m)
 
 
-def _adjust_figure(fig: go.Figure, plot_title: Optional[str] = None) -> None:
+def _adjust_figure(fig: go.Figure, plot_title: str) -> None:
     fig.layout.legend.orientation = "v"
     fig.layout.legend.title.text = ""
     fig.layout.legend.itemwidth = 40
     fig.layout.xaxis.exponentformat = "power"
-    if plot_title is not None:
-        fig.layout.title.text = plot_title
-        fig.layout.title.font = {"size": 14}
-        fig.layout.margin.t = 40
-        fig.layout.title.y = 0.95
-    else:
-        fig.layout.margin.t = 15
+
+    fig.layout.title.text = plot_title
+    fig.layout.title.font = {"size": 14}
+    fig.layout.margin.t = 40
+    fig.layout.title.y = 0.95
     fig.layout.title.x = 0.4
+
     fig.layout.paper_bgcolor = "rgba(0,0,0,0)"
     fig.layout.margin.b = 6
     fig.layout.margin.l = 10
@@ -476,13 +495,14 @@ def generate_co2_volume_figure(
     table_provider: ContainmentDataProvider,
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
-    containment_info: Dict[str, Any],
+    containment_info: ContainmentInfo,
+    legendonly_traces: Optional[List[str]],
 ) -> go.Figure:
     df = _read_terminal_co2_volumes(
         table_provider, realizations, scale, containment_info
     )
-    color_choice = containment_info["color_choice"]
-    mark_choice = containment_info["mark_choice"]
+    color_choice = containment_info.color_choice
+    mark_choice = containment_info.mark_choice
     _add_prop_to_df(df, [str(r) for r in realizations], "real")
     cat_ord, colors, marks = _prepare_pattern_and_color_options(
         df,
@@ -506,9 +526,11 @@ def generate_co2_volume_figure(
         hovertemplate="Type: %{customdata[0]}<br>Amount: %{x:.3f}<br>"
         "Realization: %{y}<br>Proportion: %{customdata[1]}<extra></extra>",
     )
+    if legendonly_traces is not None:
+        _toggle_trace_visibility(fig.data, legendonly_traces)
     fig.layout.yaxis.title = "Realization"
     fig.layout.xaxis.title = scale.value
-    _adjust_figure(fig, plot_title=containment_info["date_option"])
+    _adjust_figure(fig, plot_title=_make_title(containment_info))
     return fig
 
 
@@ -518,14 +540,14 @@ def generate_co2_time_containment_one_realization_figure(
     scale: Union[Co2MassScale, Co2VolumeScale],
     time_series_realization: int,
     y_limits: List[Optional[float]],
-    containment_info: Dict[str, Any],
+    containment_info: ContainmentInfo,
 ) -> go.Figure:
     df = _read_co2_volumes(table_provider, [time_series_realization], scale)
-    color_choice = containment_info["color_choice"]
-    mark_choice = containment_info["mark_choice"]
+    color_choice = containment_info.color_choice
+    mark_choice = containment_info.mark_choice
     _filter_columns(df, color_choice, mark_choice, containment_info)
     _filter_rows(df, color_choice, mark_choice)
-    if containment_info["sorting"] == "marking" and mark_choice != "none":
+    if containment_info.sorting == "marking" and mark_choice != "none":
         sort_order = ["date", mark_choice]
     else:
         sort_order = ["date", color_choice]
@@ -562,7 +584,7 @@ def generate_co2_time_containment_one_realization_figure(
     fig.layout.yaxis.range = y_limits
     fig.layout.xaxis.title = "Time"
     fig.layout.yaxis.title = scale.value
-    _adjust_figure(fig)
+    _adjust_figure(fig, plot_title=_make_title(containment_info, include_date=False))
     return fig
 
 
@@ -702,23 +724,27 @@ def _connect_plume_groups(
     df.drop(columns="is_merged", inplace=True)
 
 
-# pylint: disable=too-many-locals
+# pylint: disable=too-many-locals, too-many-statements
 def generate_co2_time_containment_figure(
     table_provider: ContainmentDataProvider,
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
-    containment_info: Dict[str, Any],
+    containment_info: ContainmentInfo,
+    legendonly_traces: Optional[List[str]],
 ) -> go.Figure:
     df = _read_co2_volumes(table_provider, realizations, scale)
-    color_choice = containment_info["color_choice"]
-    mark_choice = containment_info["mark_choice"]
+    color_choice = containment_info.color_choice
+    mark_choice = containment_info.mark_choice
     _filter_columns(df, color_choice, mark_choice, containment_info)
     options = _prepare_line_type_and_color_options(
         df, containment_info, color_choice, mark_choice
     )
-    active_cols_at_startup = list(
-        options[options["line_type"].isin(["solid", "0px"])]["name"]
-    )
+    if legendonly_traces is None:
+        inactive_cols_at_startup = list(
+            options[~(options["line_type"].isin(["solid", "0px"]))]["name"]
+        )
+    else:
+        inactive_cols_at_startup = legendonly_traces
     if "plume_group" in df:
         try:
             _connect_plume_groups(df, color_choice, mark_choice)
@@ -737,7 +763,7 @@ def generate_co2_time_containment_figure(
             "legendgroup": name,
             "name": name,
         }
-        if name not in active_cols_at_startup:
+        if name in inactive_cols_at_startup:
             args["visible"] = "legendonly"
         fig.add_scatter(y=[0.0], **dummy_args, **args)
 
@@ -746,7 +772,7 @@ def generate_co2_time_containment_figure(
         "Realization: %{meta[0]}<br>Proportion: %{customdata}"
     )
 
-    if containment_info["use_stats"]:
+    if containment_info.use_stats:
         df_no_real = df.drop(columns=["REAL", "realization"]).reset_index(drop=True)
         if mark_choice == "none":
             df_grouped = df_no_real.groupby(
@@ -756,11 +782,11 @@ def generate_co2_time_containment_figure(
             df_grouped = df_no_real.groupby(
                 ["date", "name", color_choice, mark_choice], as_index=False
             )
-        df_mean = df_grouped.agg(np.mean)
+        df_mean = df_grouped.agg("mean")
         df_mean["realization"] = ["mean"] * df_mean.shape[0]
-        df_p10 = df_grouped.agg(lambda x: np.quantile(x, 0.1))
+        df_p10 = df_grouped.agg(lambda x: np.quantile(x, 0.9))
         df_p10["realization"] = ["p10"] * df_p10.shape[0]
-        df_p90 = df_grouped.agg(lambda x: np.quantile(x, 0.9))
+        df_p90 = df_grouped.agg(lambda x: np.quantile(x, 0.1))
         df_p90["realization"] = ["p90"] * df_p90.shape[0]
         df = (
             pd.concat([df_mean, df_p10, df_p90])
@@ -775,7 +801,7 @@ def generate_co2_time_containment_figure(
     for rlz in realizations:
         lwd = 1.5 if rlz in ["p10", "p90"] else 2.5
         sub_df = df[df["realization"] == rlz].copy().reset_index(drop=True)
-        if not containment_info["use_stats"]:
+        if not containment_info.use_stats:
             _add_prop_to_df(
                 sub_df, np.unique(df["date"]), "date", [color_choice, mark_choice]
             )
@@ -797,9 +823,9 @@ def generate_co2_time_containment_figure(
                 "meta": [rlz, name],
                 "hovertemplate": hover_template,
             }
-            if not containment_info["use_stats"]:
+            if not containment_info.use_stats:
                 args["customdata"] = sub_df[sub_df["name"] == name]["prop"]
-            if name not in active_cols_at_startup:
+            if name in inactive_cols_at_startup:
                 args["visible"] = "legendonly"
             fig.add_scatter(
                 y=sub_df[sub_df["name"] == name]["amount"], **args, **common_args
@@ -808,7 +834,7 @@ def generate_co2_time_containment_figure(
     fig.layout.xaxis.title = "Time"
     fig.layout.yaxis.title = scale.value
     fig.layout.yaxis.autorange = True
-    _adjust_figure(fig)
+    _adjust_figure(fig, plot_title=_make_title(containment_info, include_date=False))
     return fig
 
 
@@ -816,14 +842,15 @@ def generate_co2_statistics_figure(
     table_provider: ContainmentDataProvider,
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
-    containment_info: Dict[str, Any],
+    containment_info: ContainmentInfo,
+    legend_only_traces: Optional[List[str]],
 ) -> go.Figure:
-    date_option = containment_info["date_option"]
+    date_option = containment_info.date_option
     df = _read_co2_volumes(table_provider, realizations, scale)
     df = df[df["date"] == date_option]
     df = df.drop(columns=["date"]).reset_index(drop=True)
-    color_choice = containment_info["color_choice"]
-    mark_choice = containment_info["mark_choice"]
+    color_choice = containment_info.color_choice
+    mark_choice = containment_info.mark_choice
     _filter_columns(df, color_choice, mark_choice, containment_info)
     cat_ord, colors, line_types = _prepare_pattern_and_color_options_statistics_plot(
         df,
@@ -847,10 +874,11 @@ def generate_co2_statistics_figure(
         category_orders=cat_ord,
     )
 
-    default_option = _find_default_option_statistics_figure(df, cat_ord["type"])
-    for trace in fig.data:
-        if trace.name != default_option:
-            trace.visible = "legendonly"
+    if legend_only_traces is None:
+        default_option = _find_default_legendonly(df, cat_ord["type"])
+        _toggle_trace_visibility(fig.data, default_option)
+    else:
+        _toggle_trace_visibility(fig.data, legend_only_traces)
 
     fig.update_traces(
         hovertemplate="Type: %{data.name}<br>Amount: %{x:.3f}<br>"
@@ -860,6 +888,196 @@ def generate_co2_statistics_figure(
     fig.layout.legend.tracegroupgap = 0
     fig.layout.xaxis.title = scale.value
     fig.layout.yaxis.title = "Probability"
-    _adjust_figure(fig, plot_title=containment_info["date_option"])
+    _adjust_figure(fig, plot_title=_make_title(containment_info))
+
+    return fig
+
+
+def generate_co2_box_plot_figure(
+    table_provider: ContainmentDataProvider,
+    realizations: List[int],
+    scale: Union[Co2MassScale, Co2VolumeScale],
+    containment_info: ContainmentInfo,
+    legendonly_traces: Optional[List[str]],
+) -> go.Figure:
+    eps = 0.00001
+    date_option = containment_info.date_option
+    df = _read_co2_volumes(table_provider, realizations, scale)
+    df = df[df["date"] == date_option]
+    df = df.drop(columns=["date"]).reset_index(drop=True)
+
+    color_choice = containment_info.color_choice
+    mark_choice = containment_info.mark_choice
+    _filter_columns(df, color_choice, mark_choice, containment_info)
+    cat_ord, colors, _ = _prepare_pattern_and_color_options_statistics_plot(
+        df,
+        containment_info,
+        color_choice,
+        mark_choice,
+    )
+
+    fig = go.Figure()
+    for count, type_val in enumerate(cat_ord["type"], 0):
+        df_sub = df[df["type"] == type_val]
+        if df_sub.size == 0:
+            continue
+
+        values = df_sub["amount"].to_numpy()
+        real = df_sub["realization"].to_numpy()
+
+        median_val = df_sub["amount"].median()
+        q1 = _calculate_plotly_quantiles(values, 0.25)
+        q3 = _calculate_plotly_quantiles(values, 0.75)
+        p10 = np.percentile(values, 90)
+        p90 = np.percentile(values, 10)
+        min_fence, max_fence = _calculate_plotly_whiskers(values, q1, q3)
+
+        fig.add_trace(
+            go.Box(
+                x=[count] * len(values),
+                y=values,
+                name=type_val,
+                marker_color=colors[count],
+                boxpoints="all"
+                if containment_info.box_show_points == "all_points"
+                else "outliers",
+                customdata=real,
+                hovertemplate="<span style='font-family:Courier New;'>"
+                "Type       : %{data.name}<br>Amount     : %{y:.3f}<br>"
+                "Realization: %{customdata}"
+                "</span><extra></extra>",
+                legendgroup=type_val,
+                width=0.55,
+            )
+        )
+
+        fig.add_trace(
+            go.Bar(
+                x=[count],
+                y=[values.max() - values.min() + 2 * eps],
+                base=[values.min() - eps],
+                opacity=0.0,
+                hoverinfo="none",
+                hovertemplate=(
+                    "<span style='font-family:Courier New;'>"
+                    f"Type           : {type_val}<br>"
+                    f"Max            : {values.max():.3f}<br>"
+                    f"Top whisker    : {max_fence:.3f}<br>"
+                    f"p10 (not shown): {p10:.3f}<br>"
+                    f"Q3             : {q3:.3f}<br>"
+                    f"Median         : {median_val:.3f}<br>"
+                    f"Q1             : {q1:.3f}<br>"
+                    f"p90 (not shown): {p90:.3f}<br>"
+                    f"Lower whisker  : {min_fence:.3f}<br>"
+                    f"Min            : {values.min():.3f}"
+                    "</span><extra></extra>"
+                ),
+                showlegend=False,
+                legendgroup=type_val,
+                name=type_val,
+                marker_color=colors[count],
+                width=0.56,
+            )
+        )
+
+    fig.update_layout(
+        xaxis={
+            "tickmode": "array",
+            "tickvals": list(range(len(cat_ord["type"]))),
+            "ticktext": cat_ord["type"],
+        }
+    )
+
+    if len(cat_ord["type"]) > 20 or legendonly_traces is None:
+        default_option = _find_default_legendonly(df, cat_ord["type"])
+        _toggle_trace_visibility(fig.data, default_option)
+    else:
+        _toggle_trace_visibility(fig.data, legendonly_traces)
+
+    fig.layout.yaxis.autorange = True
+    fig.layout.legend.tracegroupgap = 0
+    fig.layout.yaxis.title = scale.value
+    _adjust_figure(fig, plot_title=_make_title(containment_info))
 
     return fig
+
+
+# pylint: disable=too-many-branches
+def _make_title(c_info: ContainmentInfo, include_date: bool = True) -> str:
+    components = []
+    if include_date:
+        components.append(c_info.date_option)
+    if len(c_info.phases) > 0 and "phase" not in [
+        c_info.color_choice,
+        c_info.mark_choice,
+    ]:
+        if c_info.phase is not None and c_info.phase != "total":
+            components.append(c_info.phase.capitalize())
+        else:
+            components.append("Phase: Total")
+    if len(c_info.containments) > 0 and "containment" not in [
+        c_info.color_choice,
+        c_info.mark_choice,
+    ]:
+        if c_info.containment is not None and c_info.containment != "total":
+            components.append(c_info.containment.capitalize())
+        else:
+            components.append("All containments areas")
+    if len(c_info.zones) > 0 and "zone" not in [
+        c_info.color_choice,
+        c_info.mark_choice,
+    ]:
+        if c_info.zone is not None and c_info.zone != "all":
+            components.append(c_info.zone)
+        else:
+            components.append("All zones")
+    if (
+        c_info.regions is not None
+        and len(c_info.regions) > 0
+        and "region"
+        not in [
+            c_info.color_choice,
+            c_info.mark_choice,
+        ]
+    ):
+        if c_info.region is not None and c_info.region != "all":
+            components.append(c_info.region)
+        else:
+            components.append("All regions")
+    if len(c_info.plume_groups) > 0 and "plume_group" not in [
+        c_info.color_choice,
+        c_info.mark_choice,
+    ]:
+        if c_info.plume_group is not None and c_info.plume_group != "all":
+            components.append(c_info.plume_group)
+        else:
+            components.append("All plume groups")
+    return " - ".join(components)
+
+
+def _calculate_plotly_quantiles(values: np.ndarray, percentile: float) -> float:
+    values_sorted = values.copy()
+    values_sorted.sort()
+    n_val = len(values_sorted)
+    a = n_val * percentile - 0.5
+    if a.is_integer():
+        return float(values_sorted[int(a)])
+    return float(np.interp(a, list(range(0, n_val)), values_sorted))
+
+
+def _calculate_plotly_whiskers(
+    values: np.ndarray, q1: float, q3: float
+) -> Tuple[float, float]:
+    values_sorted = values.copy()
+    values_sorted.sort()
+    a = q1 - 1.5 * (q3 - q1)
+    b = q3 + 1.5 * (q3 - q1)
+    return values[values >= a].min(), values[values <= b].max()
+
+
+def _toggle_trace_visibility(traces: List, legendonly_names: List[str]) -> None:
+    for t in traces:
+        if t.name in legendonly_names:
+            t.visible = "legendonly"
+        else:
+            t.visible = True