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

webviz_subsurface/plugins/_co2_leakage/_utilities/summary_graphs.py

@@ -1,54 +1,53 @@
-import dataclasses
-from typing import Iterable, List, Union
+from typing import Union
 
 import numpy as np
-import pandas as pd
 import plotly.colors
 import plotly.graph_objects as go
 
-from webviz_subsurface._providers import EnsembleTableProvider
+from webviz_subsurface.plugins._co2_leakage._utilities.containment_data_provider import (
+    ContainmentDataProvider,
+)
 from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
     Co2MassScale,
     Co2VolumeScale,
 )
+from webviz_subsurface.plugins._co2_leakage._utilities.unsmry_data_provider import (
+    UnsmryDataProvider,
+)
 
 
 # pylint: disable=too-many-locals
 def generate_summary_figure(
-    table_provider_unsmry: EnsembleTableProvider,
-    realizations_unsmry: List[int],
+    unsmry_provider: UnsmryDataProvider,
     scale: Union[Co2MassScale, Co2VolumeScale],
-    table_provider_containment: EnsembleTableProvider,
-    realizations_containment: List[int],
+    containment_provider: ContainmentDataProvider,
 ) -> go.Figure:
-    columns_unsmry = _column_subset_unsmry(table_provider_unsmry)
-    columns_containment = _column_subset_containment(table_provider_containment)
-    df_unsmry = _read_dataframe(
-        table_provider_unsmry, realizations_unsmry, columns_unsmry, scale
-    )
-    df_containment = _read_dataframe_containment(
-        table_provider_containment, realizations_containment, columns_containment, scale
-    )
-    fig = go.Figure()
-    showlegend = True
+    df_unsmry = unsmry_provider.extract(scale)
+    df_containment = containment_provider.extract_condensed_dataframe(scale)
 
+    # TODO: expose these directly from data providers?
     r_min = min(df_unsmry.REAL)
-    unsmry_last_total = df_unsmry[df_unsmry.REAL == r_min]["total"].iloc[-1]
-    unsmry_last_mobile = df_unsmry[df_unsmry.REAL == r_min][columns_unsmry.mobile].iloc[
-        -1
-    ]
-    unsmry_last_dissolved = df_unsmry[df_unsmry.REAL == r_min][
-        columns_unsmry.dissolved
+    unsmry_last_total = df_unsmry[df_unsmry.REAL == r_min][
+        unsmry_provider.colname_total
     ].iloc[-1]
-    containment_last_total = df_containment[df_containment.REAL == r_min]["total"].iloc[
-        -1
-    ]
-    containment_last_mobile = df_containment[df_containment.REAL == r_min][
-        columns_containment.mobile
+    unsmry_last_mobile = df_unsmry[df_unsmry.REAL == r_min][
+        unsmry_provider.colname_mobile
     ].iloc[-1]
-    containment_last_dissolved = df_containment[df_containment.REAL == r_min][
-        columns_containment.dissolved
+    unsmry_last_dissolved = df_unsmry[df_unsmry.REAL == r_min][
+        unsmry_provider.colname_dissolved
     ].iloc[-1]
+
+    containment_reference = df_containment[df_containment.REAL == r_min]
+    containment_last_total = containment_reference[
+        containment_reference["phase"] == "total"
+    ]["amount"].iloc[-1]
+    containment_last_mobile = containment_reference[
+        containment_reference["phase"] == "free_gas"
+    ]["amount"].iloc[-1]
+    containment_last_dissolved = containment_reference[
+        containment_reference["phase"] == "dissolved"
+    ]["amount"].iloc[-1]
+    # ---
     last_total_err_percentage = (
         100.0 * abs(containment_last_total - unsmry_last_total) / unsmry_last_total
     )
@@ -64,76 +63,75 @@ def generate_summary_figure(
     last_mobile_err_percentage = np.round(last_mobile_err_percentage, 2)
     last_dissolved_err_percentage = np.round(last_dissolved_err_percentage, 2)
 
+    _colors = {
+        "total": plotly.colors.qualitative.Plotly[3],
+        "mobile": plotly.colors.qualitative.Plotly[2],
+        "dissolved": plotly.colors.qualitative.Plotly[0],
+        "trapped": plotly.colors.qualitative.Plotly[1],
+    }
+
+    fig = go.Figure()
+    showlegend = True
     for _, sub_df in df_unsmry.groupby("realization"):
-        colors = plotly.colors.qualitative.Plotly
         fig.add_scatter(
-            x=sub_df[columns_unsmry.time],
-            y=sub_df["total"],
+            x=sub_df[unsmry_provider.colname_date],
+            y=sub_df[unsmry_provider.colname_total],
             name="UNSMRY",
-            legendgroup="group_1",
+            legendgroup="total",
             legendgrouptitle_text=f"Total ({last_total_err_percentage} %)",
             showlegend=showlegend,
-            marker_color=colors[3],
+            marker_color=_colors["total"],
         )
         fig.add_scatter(
-            x=sub_df[columns_unsmry.time],
-            y=sub_df[columns_unsmry.mobile],
-            name=f"UNSMRY ({columns_unsmry.mobile})",
-            legendgroup="group_2",
+            x=sub_df[unsmry_provider.colname_date],
+            y=sub_df[unsmry_provider.colname_mobile],
+            name=f"UNSMRY ({unsmry_provider.colname_mobile})",
+            legendgroup="mobile",
             legendgrouptitle_text=f"Mobile ({last_mobile_err_percentage} %)",
             showlegend=showlegend,
-            marker_color=colors[2],
+            marker_color=_colors["mobile"],
         )
         fig.add_scatter(
-            x=sub_df[columns_unsmry.time],
-            y=sub_df[columns_unsmry.dissolved],
-            name=f"UNSMRY ({columns_unsmry.dissolved})",
-            legendgroup="group_3",
+            x=sub_df[unsmry_provider.colname_date],
+            y=sub_df[unsmry_provider.colname_dissolved],
+            name=f"UNSMRY ({unsmry_provider.colname_dissolved})",
+            legendgroup="dissolved",
             legendgrouptitle_text=f"Dissolved ({last_dissolved_err_percentage} %)",
             showlegend=showlegend,
-            marker_color=colors[0],
+            marker_color=_colors["dissolved"],
         )
         fig.add_scatter(
-            x=sub_df[columns_unsmry.time],
-            y=sub_df[columns_unsmry.trapped],
-            name=f"UNSMRY ({columns_unsmry.trapped})",
-            legendgroup="group_4",
+            x=sub_df[unsmry_provider.colname_date],
+            y=sub_df[unsmry_provider.colname_trapped],
+            name=f"UNSMRY ({unsmry_provider.colname_trapped})",
+            legendgroup="trapped",
             legendgrouptitle_text="Trapped",
             showlegend=showlegend,
-            marker_color=colors[1],
+            marker_color=_colors["trapped"],
         )
         showlegend = False
-    showlegend = True
-    for _, sub_df in df_containment.groupby("realization"):
-        colors = plotly.colors.qualitative.Plotly
-        fig.add_scatter(
-            x=sub_df[columns_containment.time],
-            y=sub_df["total"],
-            name="Containment script",
-            legendgroup="group_1",
-            showlegend=showlegend,
-            marker_color=colors[3],
-            line_dash="dash",
-        )
-        fig.add_scatter(
-            x=sub_df[columns_containment.time],
-            y=sub_df[columns_containment.mobile],
-            name=f"Containment script ({columns_containment.mobile})",
-            legendgroup="group_2",
-            showlegend=showlegend,
-            marker_color=colors[2],
-            line_dash="dash",
-        )
+
+    _col_names = {
+        "total": "total",
+        "free_gas": "mobile",
+        "dissolved": "dissolved",
+        "trapped_gas": "trapped",
+    }
+
+    first_real = None
+    for (real, phase), sub_df in df_containment.groupby(["REAL", "phase"]):
+        if first_real is None:
+            first_real = real
         fig.add_scatter(
-            x=sub_df[columns_containment.time],
-            y=sub_df[columns_containment.dissolved],
-            name=f"Containment script ({columns_containment.dissolved})",
-            legendgroup="group_3",
-            showlegend=showlegend,
-            marker_color=colors[0],
+            x=sub_df["date"],
+            y=sub_df["amount"],
+            name=f"Containment script ({phase})",
+            legendgroup=_col_names[phase],
+            showlegend=bool(first_real == real),
+            marker_color=_colors[_col_names[phase]],
             line_dash="dash",
         )
-        showlegend = False
+
     fig.layout.xaxis.title = "Time"
     fig.layout.yaxis.title = f"Amount CO2 [{scale.value}]"
     fig.layout.paper_bgcolor = "rgba(0,0,0,0)"
@@ -142,97 +140,3 @@ def generate_summary_figure(
     fig.layout.margin.l = 10
     fig.layout.margin.r = 10
     return fig
-
-
-@dataclasses.dataclass
-class _ColumnNames:
-    time: str
-    dissolved: str
-    trapped: str
-    mobile: str
-
-    def values(self) -> Iterable[str]:
-        return dataclasses.asdict(self).values()
-
-
-@dataclasses.dataclass
-class _ColumnNamesContainment:
-    time: str
-    dissolved: str
-    mobile: str
-
-    def values(self) -> Iterable[str]:
-        return dataclasses.asdict(self).values()
-
-
-def _read_dataframe(
-    table_provider: EnsembleTableProvider,
-    realizations: List[int],
-    columns: _ColumnNames,
-    co2_scale: Union[Co2MassScale, Co2VolumeScale],
-) -> pd.DataFrame:
-    full = pd.concat(
-        [
-            table_provider.get_column_data(list(columns.values()), [real]).assign(
-                realization=real
-            )
-            for real in realizations
-        ]
-    )
-    full["total"] = (
-        full[columns.dissolved] + full[columns.trapped] + full[columns.mobile]
-    )
-    for col in [columns.dissolved, columns.trapped, columns.mobile, "total"]:
-        if co2_scale == Co2MassScale.MTONS:
-            full[col] = full[col] / 1e9
-        elif co2_scale == Co2MassScale.NORMALIZE:
-            full[col] = full[col] / full["total"].max()
-    return full
-
-
-def _read_dataframe_containment(
-    table_provider: EnsembleTableProvider,
-    realizations: List[int],
-    columns: _ColumnNamesContainment,
-    co2_scale: Union[Co2MassScale, Co2VolumeScale],
-) -> pd.DataFrame:
-    full = pd.concat(
-        [
-            table_provider.get_column_data(list(columns.values()), [real]).assign(
-                realization=real
-            )
-            for real in realizations
-        ]
-    )
-    full["total"] = full[columns.dissolved] + full[columns.mobile]
-    for col in [columns.dissolved, columns.mobile, "total"]:
-        if co2_scale == Co2MassScale.MTONS:
-            full[col] = full[col] / 1e9
-        elif co2_scale == Co2MassScale.NORMALIZE:
-            full[col] = full[col] / full["total"].max()
-    return full
-
-
-def _column_subset_unsmry(table_provider: EnsembleTableProvider) -> _ColumnNames:
-    existing = set(table_provider.column_names())
-    assert "DATE" in existing
-    # Try PFLOTRAN names
-    col_names = _ColumnNames("DATE", "FGMDS", "FGMTR", "FGMGP")
-    if set(col_names.values()).issubset(existing):
-        return col_names
-    # Try Eclipse names
-    col_names = _ColumnNames("DATE", "FWCD", "FGCDI", "FGCDM")
-    if set(col_names.values()).issubset(existing):
-        return col_names
-    raise KeyError(f"Could not find suitable data columns among: {', '.join(existing)}")
-
-
-def _column_subset_containment(
-    table_provider: EnsembleTableProvider,
-) -> _ColumnNamesContainment:
-    existing = set(table_provider.column_names())
-    assert "date" in existing
-    col_names = _ColumnNamesContainment("date", "total_aqueous", "total_gas")
-    if set(col_names.values()).issubset(existing):
-        return col_names
-    raise KeyError(f"Could not find suitable data columns among: {', '.join(existing)}")

webviz_subsurface/plugins/_co2_leakage/_utilities/surface_publishing.py

@@ -17,12 +17,15 @@ from webviz_subsurface._providers import (
 from webviz_subsurface._providers.ensemble_surface_provider.ensemble_surface_provider import (
     SurfaceStatistic,
 )
-from webviz_subsurface.plugins._co2_leakage._utilities.generic import MapAttribute
+from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
+    FilteredMapAttribute,
+    MapType,
+)
 from webviz_subsurface.plugins._co2_leakage._utilities.plume_extent import (
     truncate_surfaces,
 )
 
-SCALE_DICT = {"kg": 1, "tons": 1000, "M tons": 1000000}
+SCALE_DICT = {"kg": 0.001, "tons": 1, "M tons": 1e6}
 
 
 @dataclass
@@ -44,10 +47,13 @@ def publish_and_get_surface_metadata(
     provider: EnsembleSurfaceProvider,
     address: Union[SurfaceAddress, TruncatedSurfaceAddress],
     visualization_info: Dict[str, Any],
-    map_attribute_names: Dict[MapAttribute, str],
+    map_attribute_names: FilteredMapAttribute,
 ) -> Tuple[Optional[SurfaceImageMeta], Optional[str], Optional[Any]]:
     if isinstance(address, TruncatedSurfaceAddress):
-        return _publish_and_get_truncated_surface_metadata(server, provider, address)
+        return (
+            *_publish_and_get_truncated_surface_metadata(server, provider, address),
+            None,
+        )
     provider_id: str = provider.provider_id()
     qualified_address = QualifiedSurfaceAddress(provider_id, address)
     surf_meta = server.get_surface_metadata(qualified_address)
@@ -61,22 +67,26 @@ def publish_and_get_surface_metadata(
         if not surface:
             warnings.warn(f"Could not find surface file with properties: {address}")
             return None, None, None
-        if address.attribute in [
-            map_attribute_names[MapAttribute.MASS],
-            map_attribute_names[MapAttribute.FREE],
-            map_attribute_names[MapAttribute.DISSOLVED],
-        ]:
+        address_map_attribute = next(
+            (
+                key
+                for key, value in map_attribute_names.filtered_values.items()
+                if value == address.attribute
+            ),
+            None,
+        )
+        assert address_map_attribute is not None
+        if MapType[address_map_attribute.name].value == "MASS":
             surface.values = surface.values / SCALE_DICT[visualization_info["unit"]]
-        summed_mass = np.ma.sum(surface.values)
+            summed_mass = np.ma.sum(surface.values)
         if (
-            address.attribute
-            not in [
-                map_attribute_names[MapAttribute.MIGRATION_TIME_SGAS],
-                map_attribute_names[MapAttribute.MIGRATION_TIME_AMFG],
-            ]
-            and visualization_info["threshold"] >= 0
+            MapType[address_map_attribute.name].value not in ["PLUME", "MIGRATION_TIME"]
+            and visualization_info["thresholds"][visualization_info["attribute"]] >= 0
         ):
-            surface.operation("elile", visualization_info["threshold"])
+            surface.operation(
+                "elile",
+                visualization_info["thresholds"][visualization_info["attribute"]],
+            )
         server.publish_surface(qualified_address, surface)
         surf_meta = server.get_surface_metadata(qualified_address)
     return surf_meta, server.encode_partial_url(qualified_address), summed_mass
@@ -86,7 +96,7 @@ def _publish_and_get_truncated_surface_metadata(
     server: SurfaceImageServer,
     provider: EnsembleSurfaceProvider,
     address: TruncatedSurfaceAddress,
-) -> Tuple[Optional[SurfaceImageMeta], str, Optional[Any]]:
+) -> Tuple[Optional[SurfaceImageMeta], str]:
     qualified_address = QualifiedSurfaceAddress(
         provider.provider_id(),
         # TODO: Should probably use a dedicated address type for this. Statistical surface
@@ -102,15 +112,13 @@ def _publish_and_get_truncated_surface_metadata(
         ),
     )
     surf_meta = server.get_surface_metadata(qualified_address)
-    summed_mass = None
     if surf_meta is None:
         surface = _generate_surface(provider, address)
         if surface is None:
             raise ValueError(f"Could not generate surface for address: {address}")
-        summed_mass = np.ma.sum(surface.values)
         server.publish_surface(qualified_address, surface)
         surf_meta = server.get_surface_metadata(qualified_address)
-    return surf_meta, server.encode_partial_url(qualified_address), summed_mass
+    return surf_meta, server.encode_partial_url(qualified_address)
 
 
 def _generate_surface(

webviz_subsurface/plugins/_co2_leakage/_utilities/unsmry_data_provider.py

@@ -0,0 +1,108 @@
+from typing import Tuple, Union
+
+import pandas as pd
+
+from webviz_subsurface._providers import EnsembleTableProvider
+from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
+    Co2MassScale,
+    Co2VolumeScale,
+    MenuOptions,
+)
+
+_PFLOTRAN_COLNAMES = ("DATE", "FGMDS", "FGMTR", "FGMGP")
+_ECLIPSE_COLNAMES = ("DATE", "FWCD", "FGCDI", "FGCDM")
+
+
+class UnsmryDataValidationError(Exception):
+    pass
+
+
+class UnsmryDataProvider:
+    def __init__(self, provider: EnsembleTableProvider):
+        UnsmryDataProvider._validate(provider)
+        self._provider = provider
+        (
+            self._colname_date,
+            self._colname_dissolved,
+            self._colname_trapped,
+            self._colname_mobile,
+        ) = UnsmryDataProvider._column_subset_unsmry(provider)
+        self._colname_total = "TOTAL"
+
+    @property
+    def menu_options(self) -> MenuOptions:
+        return {
+            "zones": [],
+            "regions": [],
+            "phases": ["total", "gas", "dissolved"],
+            "plume_groups": [],
+            "dates": [],
+        }
+
+    @property
+    def colname_date(self) -> str:
+        return self._colname_date
+
+    @property
+    def colname_dissolved(self) -> str:
+        return self._colname_dissolved
+
+    @property
+    def colname_trapped(self) -> str:
+        return self._colname_trapped
+
+    @property
+    def colname_mobile(self) -> str:
+        return self._colname_mobile
+
+    @property
+    def colname_total(self) -> str:
+        return self._colname_total
+
+    def extract(self, scale: Union[Co2MassScale, Co2VolumeScale]) -> pd.DataFrame:
+        columns = [
+            self._colname_date,
+            self._colname_dissolved,
+            self._colname_trapped,
+            self._colname_mobile,
+        ]
+        full = pd.concat(
+            [
+                self._provider.get_column_data(columns, [real]).assign(realization=real)
+                for real in self._provider.realizations()
+            ]
+        )
+        full[self._colname_total] = (
+            full[self._colname_dissolved]
+            + full[self._colname_trapped]
+            + full[self.colname_mobile]
+        )
+        total_max = full[self._colname_total].max()
+        for col in columns[1:] + [self._colname_total]:
+            if scale == Co2MassScale.MTONS:
+                full[col] = full[col] / 1e9
+            elif scale == Co2MassScale.NORMALIZE:
+                full[col] = full[col] / total_max
+        return full
+
+    @staticmethod
+    def _column_subset_unsmry(
+        provider: EnsembleTableProvider,
+    ) -> Tuple[str, str, str, str]:
+        existing = set(provider.column_names())
+        # Try PFLOTRAN names
+        if set(_PFLOTRAN_COLNAMES).issubset(existing):
+            return _PFLOTRAN_COLNAMES
+        # Try Eclipse names
+        if set(_ECLIPSE_COLNAMES).issubset(existing):
+            return _ECLIPSE_COLNAMES
+        raise KeyError(
+            f"Could not find suitable data columns among: {', '.join(existing)}"
+        )
+
+    @staticmethod
+    def _validate(provider: EnsembleTableProvider) -> None:
+        try:
+            UnsmryDataProvider._column_subset_unsmry(provider)
+        except KeyError as e:
+            raise UnsmryDataValidationError from e

webviz_subsurface/plugins/_co2_leakage/views/mainview/mainview.py

@@ -13,9 +13,9 @@ class MainView(ViewABC):
     class Ids(StrEnum):
         MAIN_ELEMENT = "main-element"
 
-    def __init__(self, color_scales: List[Dict[str, Any]]):
+    def __init__(self, color_scales: List[Dict[str, Any]], content: Dict[str, bool]):
         super().__init__("Main View")
-        self._view_element = MapViewElement(color_scales)
+        self._view_element = MapViewElement(color_scales, content)
         self.add_view_element(self._view_element, self.Ids.MAIN_ELEMENT)
 
 
@@ -26,20 +26,24 @@ class MapViewElement(ViewElementABC):
         DATE_WRAPPER = "date-wrapper"
         BAR_PLOT = "bar-plot"
         TIME_PLOT = "time-plot"
-        TIME_PLOT_ONE_REAL = "time-plot-one-realization"
+        STATISTICS_PLOT = "statistics-plot"
         BAR_PLOT_ORDER = "bar-plot-order"
         CONTAINMENT_COLORS = "containment-order"
         SIZE_SLIDER = "size-slider"
         TOP_ELEMENT = "top-element"
         BOTTOM_ELEMENT = "bottom-element"
 
-    def __init__(self, color_scales: List[Dict[str, Any]]) -> None:
+    def __init__(
+        self, color_scales: List[Dict[str, Any]], content: Dict[str, bool]
+    ) -> None:
         super().__init__()
         self._color_scales = color_scales
+        self._content = content
 
     def inner_layout(self) -> Component:
-        return html.Div(
-            [
+        layout_elements = []
+        if self._content["maps"]:
+            layout_elements.append(
                 wcc.Frame(
                     # id=self.register_component_unique_id(LayoutElements.MAP_VIEW),
                     id=self.register_component_unique_id(self.Ids.TOP_ELEMENT),
@@ -78,14 +82,17 @@ class MapViewElement(ViewElementABC):
                         ),
                     ],
                     style={
-                        "height": "43vh",
+                        "height": "43vh" if self._content["any_table"] else "100%",
                     },
-                ),
+                )
+            )
+        if self._content["any_table"]:
+            layout_elements.append(
                 wcc.Frame(
                     # id=get_uuid(LayoutElements.PLOT_VIEW),
                     id=self.register_component_unique_id(self.Ids.BOTTOM_ELEMENT),
                     style={
-                        "height": "37vh",
+                        "height": "37vh" if self._content["maps"] else "100%",
                     },
                     children=[
                         html.Div(
@@ -93,12 +100,15 @@ class MapViewElement(ViewElementABC):
                                 self.register_component_unique_id(self.Ids.BAR_PLOT),
                                 self.register_component_unique_id(self.Ids.TIME_PLOT),
                                 self.register_component_unique_id(
-                                    self.Ids.TIME_PLOT_ONE_REAL
+                                    self.Ids.STATISTICS_PLOT
                                 ),
                             )
                         ),
                     ],
-                ),
+                )
+            )
+        if self._content["maps"] and self._content["any_table"]:
+            layout_elements.append(
                 html.Div(
                     [
                         wcc.Slider(
@@ -118,8 +128,10 @@ class MapViewElement(ViewElementABC):
                     style={
                         "width": "100%",
                     },
-                ),
-            ],
+                )
+            )
+        return html.Div(
+            layout_elements,
             style={
                 "display": "flex",
                 "flexDirection": "column",
@@ -131,7 +143,7 @@ class MapViewElement(ViewElementABC):
 def _summary_graph_layout(
     bar_plot_id: str,
     time_plot_id: str,
-    time_plot_one_realization_id: str,
+    statistics_plot_id: str,
 ) -> List:
     return [
         wcc.Tabs(
@@ -139,7 +151,7 @@ def _summary_graph_layout(
             value="tab-1",
             children=[
                 wcc.Tab(
-                    label="End-state containment (all realizations)",
+                    label="Containment state",
                     value="tab-1",
                     children=[
                         html.Div(
@@ -154,7 +166,7 @@ def _summary_graph_layout(
                     ],
                 ),
                 wcc.Tab(
-                    label="Containment over time (all realizations)",
+                    label="Containment over time",
                     value="tab-2",
                     children=[
                         html.Div(
@@ -169,12 +181,12 @@ def _summary_graph_layout(
                     ],
                 ),
                 wcc.Tab(
-                    label="Containment over time (one realization)",
+                    label="Statistics",
                     value="tab-3",
                     children=[
                         html.Div(
                             wcc.Graph(
-                                id=time_plot_one_realization_id,
+                                id=statistics_plot_id,
                                 figure=go.Figure(),
                                 config={
                                     "displayModeBar": False,