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

webviz_subsurface/plugins/_co2_leakage/_utilities/containment_info.py

@@ -0,0 +1,31 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+from webviz_subsurface._utils.enum_shim import StrEnum
+
+
+class StatisticsTabOption(StrEnum):
+    PROBABILITY_PLOT = "probability-plot"
+    BOX_PLOT = "box-plot"
+
+
+# pylint: disable=too-many-instance-attributes
+@dataclass(frozen=True)  # NBNB-AS: Removed slots=True (python>=3.10)
+class ContainmentInfo:
+    zone: Optional[str]
+    region: Optional[str]
+    zones: List[str]
+    regions: Optional[List[str]]
+    phase: Optional[str]
+    containment: Optional[str]
+    plume_group: Optional[str]
+    color_choice: str
+    mark_choice: str
+    sorting: str
+    phases: List[str]
+    containments: List[str]
+    plume_groups: List[str]
+    use_stats: bool
+    date_option: str
+    statistics_tab_option: StatisticsTabOption
+    box_show_points: str

webviz_subsurface/plugins/_co2_leakage/_utilities/initialization.py

@@ -77,14 +77,21 @@ def build_mapping(
 def init_map_attribute_names(
     webviz_settings: WebvizSettings,
     ensembles: List[str],
-    mapping: Optional[Dict[str, str]],
+    input_mapping: Optional[Dict[str, str]],
 ) -> FilteredMapAttribute:
-    if mapping is None:
-        # Based on name convention of xtgeoapp_grd3dmaps:
-        mapping = build_mapping(webviz_settings, ensembles)
+    default_mapping = build_mapping(webviz_settings, ensembles)
+    final_mapping = dict(default_mapping)
+    if input_mapping is not None:
+        for key, value in input_mapping.items():
+            if key in final_mapping and final_mapping[key] != value:
+                LOGGER.info(
+                    f"Conflict on attribute '{key}': prioritizing '{value}' (from input attributes)"
+                    f" over '{final_mapping[key]}' (from default attributes)"
+                )
+            final_mapping[key] = value
     final_attributes = {
         (MapAttribute[key].value if key in MapAttribute.__members__ else key): value
-        for key, value in mapping.items()
+        for key, value in final_mapping.items()
     }
     return FilteredMapAttribute(final_attributes)
 
@@ -124,7 +131,7 @@ def init_polygon_provider_handlers(
     options: Optional[BoundarySettings],
 ) -> Dict[str, PolygonHandler]:
     filled_options: BoundarySettings = {
-        "polygon_file_pattern": "share/results/polygon/*.csv",
+        "polygon_file_pattern": "share/results/polygons/*.csv",
         "attribute": "boundary",
         "hazardous_name": "hazardous",
         "containment_name": "containment",
@@ -157,8 +164,10 @@ def init_unsmry_data_providers(
 
 def init_containment_data_providers(
     ensemble_roots: Dict[str, str],
-    table_rel_path: str,
+    table_rel_path: Optional[str],
 ) -> Dict[str, ContainmentDataProvider]:
+    if table_rel_path is None:
+        return {}
     factory = EnsembleTableProviderFactory.instance()
     providers = {
         ens: _init_ensemble_table_provider(factory, ens, ens_path, table_rel_path)

webviz_subsurface/plugins/_co2_leakage/_utilities/surface_publishing.py

@@ -54,6 +54,26 @@ def publish_and_get_surface_metadata(
             *_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)
@@ -67,15 +87,7 @@ def publish_and_get_surface_metadata(
         if not surface:
             warnings.warn(f"Could not find surface file with properties: {address}")
             return None, None, 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 == "MASS":
             surface.values = surface.values / SCALE_DICT[visualization_info["unit"]]
             summed_mass = np.ma.sum(surface.values)
@@ -144,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/views/mainview/mainview.py

@@ -2,12 +2,14 @@ from typing import Any, Dict, List
 
 import plotly.graph_objects as go
 import webviz_core_components as wcc
-from dash import html
+from dash import dcc, html
 from dash.development.base_component import Component
 from webviz_config.utils import StrEnum
 from webviz_config.webviz_plugin_subclasses import ViewABC, ViewElementABC
 from webviz_subsurface_components import SubsurfaceViewer
 
+from webviz_subsurface.plugins._co2_leakage._types import LegendData
+
 
 class MainView(ViewABC):
     class Ids(StrEnum):
@@ -32,6 +34,7 @@ class MapViewElement(ViewElementABC):
         SIZE_SLIDER = "size-slider"
         TOP_ELEMENT = "top-element"
         BOTTOM_ELEMENT = "bottom-element"
+        LEGEND_DATA_STORE = "legend-data-store"
 
     def __init__(
         self, color_scales: List[Dict[str, Any]], content: Dict[str, bool]
@@ -107,6 +110,16 @@ class MapViewElement(ViewElementABC):
                     ],
                 )
             )
+            layout_elements.append(
+                dcc.Store(
+                    id=self.register_component_unique_id(self.Ids.LEGEND_DATA_STORE),
+                    data=LegendData(
+                        bar_legendonly=None,
+                        time_legendonly=None,
+                        stats_legendonly=None,
+                    ),
+                )
+            )
         if self._content["maps"] and self._content["any_table"]:
             layout_elements.append(
                 html.Div(