webviz-subsurface 0.2.30__py3-none-any.whl → 0.2.32__py3-none-any.whl

webviz_subsurface/plugins/_co2_leakage/_utilities/co2volume.py

@@ -1,7 +1,9 @@
+import warnings
+from datetime import datetime as dt
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
-import pandas
+import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 
@@ -10,7 +12,6 @@ from webviz_subsurface._utils.enum_shim import StrEnum
 from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
     Co2MassScale,
     Co2VolumeScale,
-    ContainmentViews,
 )
 
 
@@ -45,100 +46,51 @@ def _read_dataframe(
     table_provider: EnsembleTableProvider,
     realization: int,
     scale_factor: float,
-    containment_info: Dict[str, Union[str, None, List[str]]],
-) -> pandas.DataFrame:
+) -> pd.DataFrame:
     df = table_provider.get_column_data(table_provider.column_names(), [realization])
-    if any(split in list(df.columns) for split in ["zone", "region"]):
-        df = _process_containment_information(df, containment_info)
-        if containment_info["containment_view"] != ContainmentViews.CONTAINMENTSPLIT:
-            df["aqueous"] = (
-                df["aqueous_contained"]
-                + df["aqueous_outside"]
-                + df["aqueous_hazardous"]
-            )
-            df["gas"] = df["gas_contained"] + df["gas_outside"] + df["gas_hazardous"]
-            df = df.drop(
-                columns=[
-                    "aqueous_contained",
-                    "aqueous_outside",
-                    "aqueous_hazardous",
-                    "gas_contained",
-                    "gas_outside",
-                    "gas_hazardous",
-                ]
-            )
     if scale_factor == 1.0:
         return df
-    for col in df.columns:
-        if col not in ["date", "zone", "region"]:
-            df[col] /= scale_factor
+    df["amount"] /= scale_factor
     return df
 
 
-def read_zone_and_region_options(
+def read_menu_options(
     table_provider: EnsembleTableProvider,
     realization: int,
+    relpath: str,
 ) -> Dict[str, List[str]]:
-    df = table_provider.get_column_data(table_provider.column_names(), [realization])
+    col_names = table_provider.column_names()
+    df = table_provider.get_column_data(col_names, [realization])
+    required_columns = ["date", "amount", "phase", "containment", "zone", "region"]
+    missing_columns = [col for col in required_columns if col not in col_names]
+    if len(missing_columns) > 0:
+        raise KeyError(
+            f"Missing expected columns {', '.join(missing_columns)} in {relpath}"
+            f" in realization {realization} (and possibly other csv-files). "
+            f"Provided files are likely from an old version of ccs-scripts."
+        )
     zones = ["all"]
-    if "zone" in list(df.columns):
-        for zone in list(df["zone"]):
-            if zone not in zones:
-                zones.append(zone)
+    for zone in list(df["zone"]):
+        if zone not in zones:
+            zones.append(zone)
     regions = ["all"]
-    if "region" in list(df.columns):
-        for region in list(df["region"]):
-            if region not in regions:
-                regions.append(region)
+    for region in list(df["region"]):
+        if region not in regions:
+            regions.append(region)
+    if "free_gas" in list(df["phase"]):
+        phases = ["total", "free_gas", "trapped_gas", "aqueous"]
+    else:
+        phases = ["total", "gas", "aqueous"]
     return {
         "zones": zones if len(zones) > 1 else [],
         "regions": regions if len(regions) > 1 else [],
+        "phases": phases,
     }
 
 
-def _process_containment_information(
-    df: pandas.DataFrame,
-    containment_info: Dict[str, Union[str, None, List[str]]],
-) -> pandas.DataFrame:
-    view = containment_info["containment_view"]
-    if view == ContainmentViews.ZONESPLIT:
-        return (
-            df[df["zone"] != "all"]
-            .drop(columns="region", errors="ignore")
-            .reset_index(drop=True)
-        )
-    if view == ContainmentViews.REGIONSPLIT:
-        return (
-            df[df["region"] != "all"]
-            .drop(columns="zone", errors="ignore")
-            .reset_index(drop=True)
-        )
-    zone = containment_info["zone"]
-    region = containment_info["region"]
-    if zone not in ["all", None]:
-        if zone in list(df["zone"]):
-            return df[df["zone"] == zone].drop(
-                columns=["zone", "region"], errors="ignore"
-            )
-        print(f"Zone {zone} not found, using sum for each unique date.")
-    elif region not in ["all", None]:
-        if region in list(df["region"]):
-            return df[df["region"] == region].drop(
-                columns=["zone", "region"], errors="ignore"
-            )
-        print(f"Region {region} not found, using sum for each unique date.")
-    if "zone" in list(df.columns):
-        if "region" in list(df.columns):
-            return df[
-                [a and b for a, b in zip(df["zone"] == "all", df["region"] == "all")]
-            ].drop(columns=["zone", "region"])
-        df = df[df["zone"] == "all"].drop(columns=["zone"])
-    elif "region" in list(df.columns):
-        df = df[df["region"] == "all"].drop(columns=["region"])
-    return df
-
-
-def _split_colors(num_cols: int, split: str = "zone") -> List[str]:
+def _get_colors(num_cols: int = 3, split: str = "zone") -> List[str]:
+    if split == "containment":
+        return [_COLOR_HAZARDOUS, _COLOR_OUTSIDE, _COLOR_CONTAINED]
     options = list(_COLOR_ZONES)
     if split == "region":
         options.reverse()
@@ -149,6 +101,130 @@ def _split_colors(num_cols: int, split: str = "zone") -> List[str]:
     return new_cols[:num_cols]
 
 
+def _get_marks(num_marks: int, mark_choice: str) -> List[str]:
+    if mark_choice == "none":
+        return [""] * num_marks
+    if mark_choice == "containment":
+        return ["x", "/", ""]
+    if mark_choice in ["zone", "region"]:
+        base_pattern = ["", "/", "x", "-", "\\", "+", "|", "."]
+        if num_marks > len(base_pattern):
+            base_pattern *= int(np.ceil(num_marks / len(base_pattern)))
+            warnings.warn(
+                f"More {mark_choice}s than pattern options. "
+                f"Some {mark_choice}s will share pattern."
+            )
+        return base_pattern[:num_marks]
+    return ["", "/"] if num_marks == 2 else ["", ".", "/"]
+
+
+def _get_line_types(mark_options: List[str], mark_choice: str) -> List[str]:
+    if mark_choice == "none":
+        return ["solid"]
+    if mark_choice == "containment":
+        return ["dash", "dot", "solid"]
+    if mark_choice in ["zone", "region"]:
+        if len(mark_options) > 8:
+            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 ["dot", "dash"] if "gas" in mark_options else ["dot", "dashdot", "dash"]
+
+
+def _prepare_pattern_and_color_options(
+    df: pd.DataFrame,
+    containment_info: Dict,
+    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"]
+    num_colors = len(color_options)
+    num_marks = num_colors if mark_choice == "none" else len(mark_options)
+    marks = _get_marks(num_marks, mark_choice)
+    colors = _get_colors(num_colors, color_choice)
+    if mark_choice == "none":
+        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":
+        cat_ord = {
+            "type": [", ".join((c, m)) for c in color_options for m in mark_options],
+        }
+        colors = [c for c in colors for _ in range(num_marks)]
+        marks = marks * num_colors
+    else:
+        cat_ord = {
+            "type": [", ".join((c, m)) for m in mark_options for c in color_options],
+        }
+        colors = colors * num_marks
+        marks = [m for m in marks for _ in range(num_colors)]
+    return cat_ord, colors, marks
+
+
+def _prepare_line_type_and_color_options(
+    df: pd.DataFrame,
+    containment_info: Dict,
+    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"])
+    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":
+        mark_options = ["total"] + mark_options
+        line_types = ["solid"] + line_types
+        filter_mark = False
+    if color_choice == "containment":
+        color_options = ["total"] + color_options
+        colors = ["black"] + colors
+    else:
+        _filter_rows(df, color_choice, mark_choice, filter_mark)
+    if mark_choice == "none":
+        df["name"] = df[color_choice]
+        return pd.DataFrame(
+            {
+                "name": color_options,
+                "color": colors,
+                "line_type": line_types * len(colors),
+            }
+        )
+    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":
+        options = pd.DataFrame(
+            {
+                "name": [
+                    ", ".join((c, m)) for c in color_options for m in mark_options
+                ],
+                "color": [c for c in colors for _ in mark_options],
+                "line_type": [l for _ in colors for l in line_types],
+            }
+        )
+    else:
+        options = pd.DataFrame(
+            {
+                "name": [
+                    ", ".join((c, m)) for m in mark_options for c in color_options
+                ],
+                "color": [c for _ in mark_options for c in colors],
+                "line_type": [l for l in line_types for _ in colors],
+            }
+        )
+    _change_names(options, color_options, mark_options)
+    return options
+
+
 def _find_scale_factor(
     table_provider: EnsembleTableProvider,
     scale: Union[Co2MassScale, Co2VolumeScale],
@@ -168,110 +244,161 @@ def _read_terminal_co2_volumes(
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
     containment_info: Dict[str, Union[str, None, List[str]]],
-) -> pandas.DataFrame:
-    view = containment_info["containment_view"]
+) -> pd.DataFrame:
     records: Dict[str, List[Any]] = {
         "real": [],
         "amount": [],
-        "phase": [],
         "sort_key": [],
         "sort_key_secondary": [],
     }
-    if view == ContainmentViews.ZONESPLIT:
-        records["zone"] = []
-    elif view == ContainmentViews.REGIONSPLIT:
-        records["region"] = []
-    else:
-        records["containment"] = []
+    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] = []
+    if mark_choice != "none":
+        records[mark_choice] = []
     scale_factor = _find_scale_factor(table_provider, scale)
+    data_frame = None
     for real in realizations:
-        df = _read_dataframe(table_provider, real, scale_factor, containment_info)
-        if view != ContainmentViews.CONTAINMENTSPLIT:
-            split = "zone" if view == ContainmentViews.ZONESPLIT else "region"
-            last_ = df[df["date"] == np.max(df["date"])]
-            for i in range(last_.shape[0]):
-                last = last_.iloc[i]
-                label = str(real)
-
-                records["real"] += [label] * 2
-                records["amount"] += [
-                    last["aqueous"],
-                    last["gas"],
-                ]
-                records["phase"] += ["aqueous", "gas"]
-                records[split] += [last[split]] * 2
-                records["sort_key"] += [label] * 2
-                records["sort_key_secondary"] += [last[split]] * 2
+        df = _read_dataframe(table_provider, real, scale_factor)
+        df = df[df["date"] == np.max(df["date"])]
+        _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)
+        if data_frame is None:
+            data_frame = df
         else:
-            last = df.iloc[np.argmax(df["date"])]
-            label = str(real)
-
-            records["real"] += [label] * 6
-            records["amount"] += [
-                last["aqueous_contained"],
-                last["gas_contained"],
-                last["aqueous_outside"],
-                last["gas_outside"],
-                last["aqueous_hazardous"],
-                last["gas_hazardous"],
-            ]
-            records["containment"] += [
-                "contained",
-                "contained",
-                "outside",
-                "outside",
-                "hazardous",
-                "hazardous",
-            ]
-            records["phase"] += ["aqueous", "gas", "aqueous", "gas", "aqueous", "gas"]
-            records["sort_key"] += [last["gas_hazardous"]] * 6
-            records["sort_key_secondary"] += [last["gas_outside"]] * 6
-    df = pandas.DataFrame.from_dict(records)
-    df.sort_values(
+            data_frame = pd.concat([data_frame, df])
+    assert data_frame is not None
+    data_frame.sort_values(
         ["sort_key", "sort_key_secondary"], inplace=True, ascending=[True, True]
     )
-    return df
+    return data_frame
+
+
+def _filter_columns(
+    df: pd.DataFrame,
+    color_choice: str,
+    mark_choice: str,
+    containment_info: Dict,
+) -> None:
+    filter_columns = [
+        col
+        for col in ["phase", "containment", "zone", "region"]
+        if col not in [mark_choice, color_choice]
+    ]
+    for col in filter_columns:
+        df.query(f'{col} == "{containment_info[col]}"', inplace=True)
+    df.drop(columns=filter_columns, inplace=True)
+
+
+def _filter_rows(
+    df: pd.DataFrame,
+    color_choice: str,
+    mark_choice: str,
+    filter_mark: bool = True,
+) -> None:
+    df.query(f'{color_choice} not in ["total", "all"]', inplace=True)
+    if mark_choice != "none" and filter_mark:
+        df.query(f'{mark_choice} not in ["total", "all"]', inplace=True)
+
+
+def _add_sort_key_and_real(
+    df: pd.DataFrame,
+    label: str,
+    containment_info: Dict,
+) -> None:
+    sort_value = np.sum(
+        df[
+            (df["phase"] == "total")
+            & (df["containment"] == "hazardous")
+            & (df["zone"] == containment_info["zone"])
+            & (df["region"] == containment_info["region"])
+        ]["amount"]
+    )
+    sort_value_secondary = np.sum(
+        df[
+            (df["phase"] == "total")
+            & (df["containment"] == "outside")
+            & (df["zone"] == containment_info["zone"])
+            & (df["region"] == containment_info["region"])
+        ]["amount"]
+    )
+    df["real"] = [label] * df.shape[0]
+    df["sort_key"] = [sort_value] * df.shape[0]
+    df["sort_key_secondary"] = [sort_value_secondary] * df.shape[0]
 
 
 def _read_co2_volumes(
     table_provider: EnsembleTableProvider,
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
-    containment_info: Dict[str, Union[str, None, List[str]]],
-) -> pandas.DataFrame:
+) -> pd.DataFrame:
     scale_factor = _find_scale_factor(table_provider, scale)
-    return pandas.concat(
+    return pd.concat(
         [
-            _read_dataframe(
-                table_provider, real, scale_factor, containment_info
-            ).assign(realization=real)
-            for real in realizations
+            _read_dataframe(table_provider, r, scale_factor).assign(realization=r)
+            for r in realizations
         ]
     )
 
 
-def _change_type_names(df: pandas.DataFrame) -> None:
-    df["type"] = df["type"].replace("total", "Total")
-    df["type"] = df["type"].replace("total_contained", "Contained")
-    df["type"] = df["type"].replace("total_outside", "Outside")
-    df["type"] = df["type"].replace("total_hazardous", "Hazardous")
-    df["type"] = df["type"].replace("total_gas", "Gas")
-    df["type"] = df["type"].replace("total_aqueous", "Aqueous")
-    df["type"] = df["type"].replace("gas_contained", "Contained mobile gas")
-    df["type"] = df["type"].replace("gas_outside", "Outside mobile gas")
-    df["type"] = df["type"].replace("gas_hazardous", "Hazardous mobile gas")
-    df["type"] = df["type"].replace("aqueous_contained", "Contained aqueous")
-    df["type"] = df["type"].replace("aqueous_outside", "Outside aqueous")
-    df["type"] = df["type"].replace("aqueous_hazardous", "Hazardous aqueous")
+def _change_names(
+    df: pd.DataFrame,
+    color_options: List[str],
+    mark_options: List[str],
+) -> None:
+    for m in mark_options + ["total", "all"]:
+        df["name"] = df["name"].replace(f"total, {m}", m)
+        df["name"] = df["name"].replace(f"all, {m}", m)
+    for m in color_options:
+        df["name"] = df["name"].replace(f"{m}, total", m)
+        df["name"] = df["name"].replace(f"{m}, all", m)
 
 
 def _adjust_figure(fig: go.Figure) -> None:
+    fig.layout.legend.orientation = "v"
+    fig.layout.legend.title.text = ""
+    fig.layout.legend.itemwidth = 40
+    fig.layout.xaxis.exponentformat = "power"
     fig.layout.title.x = 0.5
     fig.layout.paper_bgcolor = "rgba(0,0,0,0)"
     fig.layout.margin.b = 6
-    fig.layout.margin.t = 40
+    fig.layout.margin.t = 15
     fig.layout.margin.l = 10
     fig.layout.margin.r = 10
+    fig.update_layout(
+        legend={
+            "x": 1.05,
+            "xanchor": "left",
+        }
+    )
+
+
+def _add_prop_to_df(
+    df: pd.DataFrame,
+    list_to_iterate: Union[List, np.ndarray],
+    column: str,
+    filter_columns: Optional[List[str]] = None,
+) -> None:
+    prop = np.zeros(df.shape[0])
+    for element in list_to_iterate:
+        if filter_columns is None:
+            summed_amount = np.sum(df.loc[df[column] == element]["amount"])
+        else:
+            filter_for_sum = df[column] == element
+            for col in filter_columns:
+                if col in df.columns:
+                    filter_for_sum &= ~df[col].isin(["total", "all"])
+            summed_amount = np.sum(df.loc[filter_for_sum]["amount"])
+        prop[np.where(df[column] == element)[0]] = summed_amount
+    nonzero = np.where(prop > 0)[0]
+    prop[nonzero] = (
+        np.round(np.array(df["amount"])[nonzero] / prop[nonzero] * 1000) / 10
+    )
+    df["prop"] = prop
+    df["prop"] = df["prop"].map(lambda p: str(p) + "%")
 
 
 def generate_co2_volume_figure(
@@ -283,43 +410,34 @@ def generate_co2_volume_figure(
     df = _read_terminal_co2_volumes(
         table_provider, realizations, scale, containment_info
     )
-    if containment_info["containment_view"] == ContainmentViews.ZONESPLIT:
-        color = "zone"
-        cat_ord = {"zone": containment_info["zones"], "phase": ["gas", "aqueous"]}
-        colors = _split_colors(len(containment_info["zones"]))
-    elif containment_info["containment_view"] == ContainmentViews.REGIONSPLIT:
-        color = "region"
-        cat_ord = {"region": containment_info["regions"], "phase": ["gas", "aqueous"]}
-        colors = _split_colors(len(containment_info["regions"]), "region")
-    else:
-        color = "containment"
-        cat_ord = {
-            "containment": ["hazardous", "outside", "contained"],
-            "phase": ["gas", "aqueous"],
-        }
-        colors = [_COLOR_HAZARDOUS, _COLOR_OUTSIDE, _COLOR_CONTAINED]
+    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,
+        containment_info,
+        color_choice,
+        mark_choice,
+    )
     fig = px.bar(
         df,
         y="real",
         x="amount",
-        color=color,
-        pattern_shape="phase",
-        title="End-state CO<sub>2</sub> containment (all realizations)",
+        color="type",
+        color_discrete_sequence=colors,
+        pattern_shape="type" if mark_choice != "none" else None,
+        pattern_shape_sequence=marks,
         orientation="h",
         category_orders=cat_ord,
-        color_discrete_sequence=colors,
+        hover_data={"prop": True, "real": False},
     )
-    fig.layout.legend.title.text = ""
-    fig.layout.legend.orientation = "h"
-    fig.layout.legend.y = -0.3
-    fig.layout.legend.font = {"size": 8}
     fig.layout.yaxis.title = "Realization"
-    fig.layout.xaxis.exponentformat = "power"
     fig.layout.xaxis.title = scale.value
     _adjust_figure(fig)
     return fig
 
 
+# pylint: disable=too-many-locals
 def generate_co2_time_containment_one_realization_figure(
     table_provider: EnsembleTableProvider,
     scale: Union[Co2MassScale, Co2VolumeScale],
@@ -327,232 +445,176 @@ def generate_co2_time_containment_one_realization_figure(
     y_limits: List[Optional[float]],
     containment_info: Dict[str, Any],
 ) -> go.Figure:
-    df = _read_co2_volumes(
-        table_provider, [time_series_realization], scale, containment_info
-    )
-    df.sort_values(by="date", inplace=True)
-    df = df.drop(
-        columns=[
-            "realization",
-            "REAL",
-            "total",
-            "total_contained",
-            "total_outside",
-            "total_hazardous",
-            "total_gas",
-            "total_aqueous",
-        ]
-    )
-    if containment_info["containment_view"] == ContainmentViews.ZONESPLIT:
-        df = pandas.melt(df, id_vars=["date", "zone"])
-        df["variable"] = df["zone"] + ", " + df["variable"]
-        df = df.drop(columns=["zone"])
-        cat_ord = {
-            "type": [
-                zone_name + ", " + phase
-                for zone_name in containment_info["zones"]
-                for phase in ["gas", "aqueous"]
-            ]
-        }
-        pattern = ["", "/"] * len(containment_info["zones"])
-        colors = [
-            col
-            for col in _split_colors(len(containment_info["zones"]))
-            for i in range(2)
-        ]
-    elif containment_info["containment_view"] == ContainmentViews.REGIONSPLIT:
-        df = pandas.melt(df, id_vars=["date", "region"])
-        df["variable"] = df["region"] + ", " + df["variable"]
-        df = df.drop(columns=["region"])
-        cat_ord = {
-            "type": [
-                region_name + ", " + phase
-                for region_name in containment_info["regions"]
-                for phase in ["gas", "aqueous"]
-            ]
-        }
-        pattern = ["", "/"] * len(containment_info["regions"])
-        colors = [
-            col
-            for col in _split_colors(len(containment_info["regions"]), "region")
-            for i in range(2)
-        ]
+    df = _read_co2_volumes(table_provider, [time_series_realization], scale)
+    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":
+        sort_order = ["date", mark_choice]
     else:
-        df = pandas.melt(df, id_vars=["date"])
-        cat_ord = {
-            "type": [
-                "Hazardous mobile gas",
-                "Hazardous aqueous",
-                "Outside mobile gas",
-                "Outside aqueous",
-                "Contained mobile gas",
-                "Contained aqueous",
-            ]
-        }
-        pattern = ["", "/"] * 3
-        colors = [
-            _COLOR_HAZARDOUS,
-            _COLOR_HAZARDOUS,
-            _COLOR_OUTSIDE,
-            _COLOR_OUTSIDE,
-            _COLOR_CONTAINED,
-            _COLOR_CONTAINED,
-        ]
-    df = df.rename(columns={"value": "mass", "variable": "type"})
-    df.sort_values(by="date", inplace=True)
-    _change_type_names(df)
+        sort_order = ["date", color_choice]
+    df.sort_values(by=sort_order, inplace=True)
     if y_limits[0] is None and y_limits[1] is not None:
         y_limits[0] = 0.0
     elif y_limits[1] is None and y_limits[0] is not None:
-        y_limits[1] = max(df.groupby("date")["mass"].sum()) * 1.05
+        y_limits[1] = max(df.groupby("date")["amount"].sum()) * 1.05
+
+    _add_prop_to_df(df, np.unique(df["date"]), "date")
+    cat_ord, colors, marks = _prepare_pattern_and_color_options(
+        df,
+        containment_info,
+        color_choice,
+        mark_choice,
+    )
     fig = px.area(
         df,
         x="date",
-        y="mass",
+        y="amount",
         color="type",
-        category_orders=cat_ord,
         color_discrete_sequence=colors,
-        pattern_shape="type",
-        pattern_shape_sequence=pattern,  # ['', '/', '\\', 'x', '-', '|', '+', '.'],
+        pattern_shape="type" if mark_choice != "none" else None,
+        pattern_shape_sequence=marks,
+        category_orders=cat_ord,
         range_y=y_limits,
+        hover_data={
+            "prop": True,
+            "amount": ":.3f",
+        },
     )
+    _add_hover_info_in_field(fig, df, cat_ord, colors)
     fig.layout.yaxis.range = y_limits
-    fig.layout.legend.orientation = "h"
-    fig.layout.legend.title.text = ""
-    fig.layout.legend.y = -0.3
-    fig.layout.legend.font = {"size": 8}
-    fig.layout.title = "CO<sub>2</sub> containment for realization: " + str(
-        time_series_realization
-    )
     fig.layout.xaxis.title = "Time"
     fig.layout.yaxis.title = scale.value
-    fig.layout.yaxis.exponentformat = "power"
     _adjust_figure(fig)
     return fig
 
 
-def _prepare_time_figure_options(
-    df: pandas.DataFrame,
-    containment_info: Dict[str, Any],
-) -> Tuple[pandas.DataFrame, Dict[str, Tuple[str, str, str]], List[str]]:
-    view = containment_info["containment_view"]
-    if view != ContainmentViews.CONTAINMENTSPLIT:
-        split = "zone" if view == ContainmentViews.ZONESPLIT else "region"
-        options = (
-            containment_info["zones"]
-            if split == "zone"
-            else containment_info["regions"]
-        )
-        df = df.drop(
-            columns=[
-                "REAL",
-                "total_gas",
-                "total_aqueous",
-                "total_contained",
-                "total_outside",
-                "total_hazardous",
-                "region" if split == "zone" else "zone",
-            ],
-            errors="ignore",
-        )
-        df.sort_values(by=["date", "realization"], inplace=True)
-        df_ = df[["date", "realization"]][df[split] == options[0]].reset_index(
-            drop=True
-        )
-        for name in options:
-            part_df = df[["total", "gas", "aqueous"]][df[split] == name]
-            part_df = part_df.rename(
-                columns={
-                    "total": name + ", total",
-                    "gas": name + ", gas",
-                    "aqueous": name + ", aqueous",
-                }
-            ).reset_index(drop=True)
-            df_ = pandas.concat([df_, part_df], axis=1)
-        colors = _split_colors(len(options), split)
-        cols_to_plot = {}
-        for phase, line_type in zip(
-            ["total", "gas", "aqueous"], ["solid", "dot", "dash"]
-        ):
-            for name, col in zip(options, colors):
-                cols_to_plot[name + ", " + phase] = (
-                    name + ", " + phase,
-                    line_type,
-                    col,
+def spaced_dates(dates: List[str], num_between: int) -> Dict[str, List[str]]:
+    dates_list = [dt.strptime(date, "%Y-%m-%d") for date in dates]
+    date_dict: Dict[str, List[str]] = {date: [] for date in dates}
+    for i in range(len(dates_list) - 1):
+        date_dict[dates[i]].append(dates[i])
+        delta = (dates_list[i + 1] - dates_list[i]) / (num_between + 1)
+        for j in range(1, num_between + 1):
+            new_date = dates_list[i] + delta * j
+            if j <= num_between / 2:
+                date_dict[dates[i]].append(new_date.strftime("%Y-%m-%d"))
+            else:
+                date_dict[dates[i + 1]].append(new_date.strftime("%Y-%m-%d"))
+    date_dict[dates[-1]].append(dates[-1])
+    return date_dict
+
+
+def _add_hover_info_in_field(
+    fig: go.Figure,
+    df: pd.DataFrame,
+    cat_ord: Dict,
+    colors: List,
+) -> None:
+    """
+    Plots additional, invisible points in the middle of each field in the third plot,
+    solely to display hover information inside the fields
+    (which is not possible directly with plotly.express.area)
+    """
+    months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun"]
+    months += ["Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+    dates = np.unique(df["date"])
+    date_strings = {
+        date: f"{months[int(date.split('-')[1]) - 1]} {date.split('-')[0]}"
+        for date in dates
+    }
+    prev_vals = {date: 0 for date in dates}
+    date_dict = spaced_dates(dates, 4)
+    for name, color in zip(cat_ord["type"], colors):
+        sub_df = df[df["type"] == name]
+        for date in dates:
+            amount = sub_df[sub_df["date"] == date]["amount"].item()
+            prop = sub_df[sub_df["date"] == date]["prop"].item()
+            prev_val = prev_vals[date]
+            p15 = prev_val + 0.15 * amount
+            p85 = prev_val + 0.85 * amount
+            y_vals = np.linspace(p15, p85, 8).tolist() * len(date_dict[date])
+            y_vals.sort()
+            fig.add_trace(
+                go.Scatter(
+                    x=date_dict[date] * 8,
+                    y=y_vals,
+                    mode="lines",
+                    line=go.scatter.Line(color=color),
+                    text=f"type={name}<br>date={date_strings[date]}<br>"
+                    f"amount={amount:.3f}<br>prop={prop}",
+                    opacity=0,
+                    hoverinfo="text",
+                    hoveron="points",
+                    showlegend=False,
                 )
-        active_cols_at_startup = [name + ", total" for name in options]
-        df = df_
-    else:
-        df.sort_values(by="date", inplace=True)
-        cols_to_plot = {
-            "Total": ("total", "solid", _COLOR_TOTAL),
-            "Contained": ("total_contained", "solid", _COLOR_CONTAINED),
-            "Outside": ("total_outside", "solid", _COLOR_OUTSIDE),
-            "Hazardous": ("total_hazardous", "solid", _COLOR_HAZARDOUS),
-            "Gas": ("total_gas", "dot", _COLOR_TOTAL),
-            "Aqueous": ("total_aqueous", "dash", _COLOR_TOTAL),
-            "Contained mobile gas": ("gas_contained", "dot", _COLOR_CONTAINED),
-            "Outside mobile gas": ("gas_outside", "dot", _COLOR_OUTSIDE),
-            "Hazardous mobile gas": ("gas_hazardous", "dot", _COLOR_HAZARDOUS),
-            "Contained aqueous": ("aqueous_contained", "dash", _COLOR_CONTAINED),
-            "Outside aqueous": ("aqueous_outside", "dash", _COLOR_OUTSIDE),
-            "Hazardous aqueous": ("aqueous_hazardous", "dash", _COLOR_HAZARDOUS),
-        }
-        active_cols_at_startup = ["Total", "Outside", "Hazardous"]
-    return df, cols_to_plot, active_cols_at_startup
+            )
+            prev_vals[date] = prev_val + amount
 
 
+# pylint: disable=too-many-locals
 def generate_co2_time_containment_figure(
     table_provider: EnsembleTableProvider,
     realizations: List[int],
     scale: Union[Co2MassScale, Co2VolumeScale],
     containment_info: Dict[str, Any],
 ) -> go.Figure:
-    df = _read_co2_volumes(table_provider, realizations, scale, containment_info)
-    df, cols_to_plot, active_cols_at_startup = _prepare_time_figure_options(
-        df, containment_info
+    df = _read_co2_volumes(table_provider, realizations, scale)
+    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"]
     )
     fig = go.Figure()
     # Generate dummy scatters for legend entries
     dummy_args = {"x": df["date"], "mode": "lines", "hoverinfo": "none"}
-    for col, value in cols_to_plot.items():
+    for name, color, line_type in zip(
+        options["name"], options["color"], options["line_type"]
+    ):
         args = {
-            "line_dash": value[1],
-            "marker_color": value[2],
-            "legendgroup": col,
-            "name": col,
+            "line_dash": line_type,
+            "marker_color": color,
+            "legendgroup": name,
+            "name": name,
         }
-        if col not in active_cols_at_startup:
+        if name not in active_cols_at_startup:
             args["visible"] = "legendonly"
         fig.add_scatter(y=[0.0], **dummy_args, **args)
     for rlz in realizations:
-        sub_df = df[df["realization"] == rlz]
+        sub_df = df[df["realization"] == rlz].copy().reset_index()
+        _add_prop_to_df(
+            sub_df, np.unique(df["date"]), "date", [color_choice, mark_choice]
+        )
         common_args = {
             "x": sub_df["date"],
-            "hovertemplate": "%{x}: %{y}<br>Realization: %{meta[0]}",
+            "hovertemplate": "%{x}: %{y}<br>Realization: %{meta[0]}<br>Prop: %{customdata}%",
             "meta": [rlz],
             "showlegend": False,
         }
-        for col, value in cols_to_plot.items():
+        for name, color, line_type in zip(
+            options["name"], options["color"], options["line_type"]
+        ):
+            # NBNB-AS: Check this, mypy complains:
             args = {
-                "line_dash": value[1],
-                "marker_color": value[2],
-                "legendgroup": col,
-                "name": col,
+                "line_dash": line_type,
+                "marker_color": color,
+                "legendgroup": name,
+                "name": name,
+                "customdata": sub_df[sub_df["name"] == name]["prop"],  # type: ignore
             }
-            if col not in active_cols_at_startup:
+            if name not in active_cols_at_startup:
                 args["visible"] = "legendonly"
-            fig.add_scatter(y=sub_df[value[0]], **args, **common_args)
-    fig.layout.legend.orientation = "h"
-    fig.layout.legend.title.text = ""
-    fig.layout.legend.y = -0.3
-    fig.layout.legend.font = {"size": 8}
+            fig.add_scatter(
+                y=sub_df[sub_df["name"] == name]["amount"], **args, **common_args
+            )
     fig.layout.legend.tracegroupgap = 0
-    fig.layout.title = "CO<sub>2</sub> containment (all realizations)"
     fig.layout.xaxis.title = "Time"
     fig.layout.yaxis.title = scale.value
-    fig.layout.yaxis.exponentformat = "power"
     fig.layout.yaxis.autorange = True
     _adjust_figure(fig)
-    # fig.update_layout(legend=dict(font=dict(size=8)), legend_tracegroupgap=0)
     return fig