webviz-subsurface 0.2.36__py3-none-any.whl → 0.2.38__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,33 @@ 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,
+        )
+    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 == "MIGRATION_TIME" and isinstance(
+        address, StatisticalSurfaceAddress
+    ):
+        return (
+            *_publish_and_get_statistical_time_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 +87,18 @@ 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],
-        ]:
+
+        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 +108,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 +124,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(
@@ -136,3 +156,84 @@ def _generate_surface(
     template.values = plume_count
     template.values.mask = plume_count < 1e-4  # type: ignore
     return template
+
+
+def _publish_and_get_statistical_time_surface_metadata(
+    server: SurfaceImageServer,
+    provider: EnsembleSurfaceProvider,
+    address: StatisticalSurfaceAddress,
+) -> Tuple[Optional[SurfaceImageMeta], str]:
+    qualified_address = QualifiedSurfaceAddress(
+        provider.provider_id(),
+        StatisticalSurfaceAddress(
+            address.attribute,
+            address.name,
+            address.datestr,
+            address.statistic,
+            address.realizations,
+        ),
+    )
+    surf_meta = server.get_surface_metadata(qualified_address)
+    if surf_meta is None:
+        surface = _generate_statisical_time_surface(provider, address)
+        if surface is None:
+            raise ValueError(f"Could not generate surface for address: {address}")
+        server.publish_surface(qualified_address, surface)
+        surf_meta = server.get_surface_metadata(qualified_address)
+    return surf_meta, server.encode_partial_url(qualified_address)
+
+
+def _generate_statisical_time_surface(
+    provider: EnsembleSurfaceProvider,
+    address: StatisticalSurfaceAddress,
+) -> Optional[xtgeo.RegularSurface]:
+    surfaces = [
+        provider.get_surface(
+            SimulatedSurfaceAddress(
+                attribute=address.attribute,
+                name=address.name,
+                datestr=address.datestr,
+                realization=r,
+            )
+        )
+        for r in address.realizations
+    ]
+    surfaces = [s for s in surfaces if s is not None]
+    if len(surfaces) == 0:
+        return None
+    statistical_map = _statistics_on_time_map(surfaces, address.statistic)
+    if statistical_map is None:
+        return None
+    template: xtgeo.RegularSurface = surfaces[0].copy()  # type: ignore
+    template.values = statistical_map
+    return template
+
+
+# pylint: disable=too-many-return-statements
+def _statistics_on_time_map(
+    surfaces: List[xtgeo.RegularSurface],
+    statistic: SurfaceStatistic,
+) -> Optional[np.ndarray]:
+    maps = np.zeros((len(surfaces), *surfaces[0].values.shape))
+    for i, surface in enumerate(surfaces):
+        maps[i, :, :] = surface.values
+        masked = np.where(surface.values.mask)
+        maps[i, masked[0], masked[1]] = np.inf
+    if statistic == SurfaceStatistic.MEAN:
+        return _turn_inf_to_nan(np.mean(maps, axis=0))
+    if statistic == SurfaceStatistic.STDDEV:
+        return _turn_inf_to_nan(np.std(maps, axis=0))
+    if statistic == SurfaceStatistic.MINIMUM:
+        return _turn_inf_to_nan(np.min(maps, axis=0))
+    if statistic == SurfaceStatistic.MAXIMUM:
+        return _turn_inf_to_nan(np.max(maps, axis=0))
+    if statistic == SurfaceStatistic.P10:
+        return _turn_inf_to_nan(np.percentile(maps, 10, axis=0))
+    if statistic == SurfaceStatistic.P90:
+        return _turn_inf_to_nan(np.percentile(maps, 90, axis=0))
+    return None
+
+
+def _turn_inf_to_nan(surface: np.ndarray) -> np.ndarray:
+    surface[np.where(surface == np.inf)] = np.nan
+    return 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