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

webviz_subsurface/_components/tornado/_tornado_data.py

@@ -25,6 +25,9 @@ class TornadoData:
             self._cut_sensitivities_by_ref()
         self._sort_sensitivities_by_max()
         self._real_df = self._create_real_df(dframe)
+        self.mean_per_mc_sens = (
+            dframe[dframe["SENSTYPE"] == "mc"].groupby("SENSNAME")["VALUE"].mean()
+        )
 
     def _validate_input(self, dframe: pd.DataFrame) -> None:
         for col in self.REQUIRED_COLUMNS:

webviz_subsurface/_providers/ensemble_surface_provider/surface_array_server.py

@@ -61,7 +61,6 @@ class SurfaceArrayServer:
                 "CACHE_TYPE": "FileSystemCache",
                 "CACHE_DIR": cache_dir,
                 "CACHE_DEFAULT_TIMEOUT": 0,
-                "CACHE_OPTIONS": {"mode": 0o660},
             }
         )
         self._array_cache.init_app(app.server)

webviz_subsurface/_providers/ensemble_surface_provider/surface_image_server.py

@@ -3,16 +3,15 @@ import io
 import json
 import logging
 import math
+import tempfile
 from dataclasses import asdict, dataclass
 from typing import Any, List, Optional, Tuple, Union
 from urllib.parse import quote
-from uuid import uuid4
 
 import flask
 import flask_caching
 import xtgeo
 from dash import Dash
-from webviz_config.webviz_instance_info import WEBVIZ_INSTANCE_INFO
 
 from webviz_subsurface._utils.perf_timer import PerfTimer
 
@@ -46,17 +45,13 @@ class SurfaceImageMeta:
 
 class SurfaceImageServer:
     def __init__(self, app: Dash) -> None:
-        cache_dir = (
-            WEBVIZ_INSTANCE_INFO.storage_folder
-            / f"SurfaceImageServer_filecache_{uuid4()}"
-        )
+        cache_dir = tempfile.mkdtemp()
         LOGGER.debug(f"Setting up file cache in: {cache_dir}")
         self._image_cache = flask_caching.Cache(
             config={
                 "CACHE_TYPE": "FileSystemCache",
                 "CACHE_DIR": cache_dir,
                 "CACHE_DEFAULT_TIMEOUT": 0,
-                "CACHE_OPTIONS": {"mode": 0o660},
             }
         )
         self._image_cache.init_app(app.server)

webviz_subsurface/plugins/_co2_leakage/_plugin.py

@@ -22,6 +22,7 @@ from webviz_subsurface.plugins._co2_leakage._utilities.callbacks import (
     process_visualization_info,
     property_origin,
     readable_name,
+    set_plot_ids,
 )
 from webviz_subsurface.plugins._co2_leakage._utilities.fault_polygons import (
     FaultPolygonsHandler,
@@ -34,10 +35,10 @@ from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
 )
 from webviz_subsurface.plugins._co2_leakage._utilities.initialization import (
     init_map_attribute_names,
+    init_menu_options,
     init_surface_providers,
     init_table_provider,
     init_well_pick_provider,
-    init_zone_and_region_options,
     process_files,
 )
 from webviz_subsurface.plugins._co2_leakage.views.mainview.mainview import (
@@ -165,12 +166,13 @@ class CO2Leakage(WebvizPluginABC):
                 well_pick_dict,
                 map_surface_names_to_well_pick_names,
             )
-            # Zone and region options
-            self._zone_and_region_options = init_zone_and_region_options(
+            # Phase (in case of residual trapping), zone and region options
+            self._menu_options = init_menu_options(
                 ensemble_paths,
                 self._co2_table_providers,
                 self._co2_actual_volume_table_providers,
-                self._ensemble_surface_providers,
+                plume_mass_relpath,
+                plume_actual_volume_relpath,
             )
         except Exception as err:
             self._error_message = f"Plugin initialization failed: {err}"
@@ -196,7 +198,7 @@ class CO2Leakage(WebvizPluginABC):
                 self._map_attribute_names,
                 [c["name"] for c in self._color_tables],  # type: ignore
                 self._well_pick_names,
-                self._zone_and_region_options,
+                self._menu_options,
             ),
             self.Ids.MAIN_SETTINGS,
         )
@@ -229,25 +231,18 @@ class CO2Leakage(WebvizPluginABC):
             raise ValueError(f"Failed to fetch dates for attribute '{att_name}'")
         return dates
 
+    # Might want to do some refactoring if this gets too big
+    # pylint: disable=too-many-statements
     def _set_callbacks(self) -> None:
         # Cannot avoid many arguments since all the parameters are needed
         # to determine what to plot
         # pylint: disable=too-many-arguments
-        # pylint: disable=too-many-locals
         @callback(
-            Output(
-                self._settings_component(ViewSettings.Ids.CONTAINMENT_VIEW), "value"
-            ),
             Output(self._view_component(MapViewElement.Ids.BAR_PLOT), "figure"),
             Output(self._view_component(MapViewElement.Ids.TIME_PLOT), "figure"),
             Output(
                 self._view_component(MapViewElement.Ids.TIME_PLOT_ONE_REAL), "figure"
             ),
-            Output(self._view_component(MapViewElement.Ids.BAR_PLOT), "style"),
-            Output(self._view_component(MapViewElement.Ids.TIME_PLOT), "style"),
-            Output(
-                self._view_component(MapViewElement.Ids.TIME_PLOT_ONE_REAL), "style"
-            ),
             Input(self._settings_component(ViewSettings.Ids.ENSEMBLE), "value"),
             Input(self._settings_component(ViewSettings.Ids.GRAPH_SOURCE), "value"),
             Input(self._settings_component(ViewSettings.Ids.CO2_SCALE), "value"),
@@ -258,7 +253,11 @@ class CO2Leakage(WebvizPluginABC):
             Input(self._settings_component(ViewSettings.Ids.Y_MAX_GRAPH), "value"),
             Input(self._settings_component(ViewSettings.Ids.ZONE), "value"),
             Input(self._settings_component(ViewSettings.Ids.REGION), "value"),
-            Input(self._settings_component(ViewSettings.Ids.CONTAINMENT_VIEW), "value"),
+            Input(self._settings_component(ViewSettings.Ids.PHASE), "value"),
+            Input(self._settings_component(ViewSettings.Ids.CONTAINMENT), "value"),
+            Input(self._settings_component(ViewSettings.Ids.COLOR_BY), "value"),
+            Input(self._settings_component(ViewSettings.Ids.MARK_BY), "value"),
+            Input(self._settings_component(ViewSettings.Ids.SORT_PLOT), "value"),
         )
         @callback_typecheck
         def update_graphs(
@@ -272,15 +271,23 @@ class CO2Leakage(WebvizPluginABC):
             y_max_val: Optional[float],
             zone: Optional[str],
             region: Optional[str],
-            containment_view: str,
-        ) -> Tuple[Dict, go.Figure, go.Figure]:
-            out = {"figs": [no_update] * 3, "styles": [{"display": "none"}] * 3}
+            phase: str,
+            containment: str,
+            color_choice: str,
+            mark_choice: Optional[str],
+            sorting: str,
+        ) -> Tuple[Dict, go.Figure, go.Figure, go.Figure]:
+            # pylint: disable=too-many-locals
+            figs = [no_update] * 3
             cont_info = process_containment_info(
                 zone,
                 region,
-                containment_view,
-                self._zone_and_region_options[ensemble][source],
-                source,
+                phase,
+                containment,
+                color_choice,
+                mark_choice,
+                sorting,
+                self._menu_options[ensemble][source],
             )
             if source in [
                 GraphSource.CONTAINMENT_MASS,
@@ -290,12 +297,11 @@ class CO2Leakage(WebvizPluginABC):
                     y_min_val if len(y_min_auto) == 0 else None,
                     y_max_val if len(y_max_auto) == 0 else None,
                 ]
-                out["styles"] = [{}] * 3
                 if (
                     source == GraphSource.CONTAINMENT_MASS
                     and ensemble in self._co2_table_providers
                 ):
-                    out["figs"][: len(out["figs"])] = generate_containment_figures(
+                    figs[: len(figs)] = generate_containment_figures(
                         self._co2_table_providers[ensemble],
                         co2_scale,
                         realizations[0],
@@ -306,18 +312,14 @@ class CO2Leakage(WebvizPluginABC):
                     source == GraphSource.CONTAINMENT_ACTUAL_VOLUME
                     and ensemble in self._co2_actual_volume_table_providers
                 ):
-                    out["figs"][: len(out["figs"])] = generate_containment_figures(
+                    figs[: len(figs)] = generate_containment_figures(
                         self._co2_actual_volume_table_providers[ensemble],
                         co2_scale,
                         realizations[0],
                         y_limits,
                         cont_info,
                     )
-                for fig in out["figs"]:
-                    fig["layout"][
-                        "uirevision"
-                    ] = f"{source}-{co2_scale}-{cont_info['zone']}-{cont_info['region']}"
-                out["figs"][-1]["layout"]["uirevision"] += f"-{realizations}"
+                set_plot_ids(figs, source, co2_scale, cont_info, realizations)
             elif source == GraphSource.UNSMRY:
                 if self._unsmry_providers is not None:
                     if ensemble in self._unsmry_providers:
@@ -326,14 +328,13 @@ class CO2Leakage(WebvizPluginABC):
                             co2_scale,
                             self._co2_table_providers[ensemble],
                         )
-                        out["figs"][: len(u_figs)] = u_figs
-                        out["styles"][: len(u_figs)] = [{}] * len(u_figs)
+                        figs = list(u_figs)
                 else:
                     LOGGER.warning(
                         """UNSMRY file has not been specified as input.
                          Please use unsmry_relpath in the configuration."""
                     )
-            return cont_info["containment_view"], *out["figs"], *out["styles"]  # type: ignore
+            return figs  # type: ignore
 
         @callback(
             Output(self._view_component(MapViewElement.Ids.DATE_SLIDER), "marks"),
@@ -352,15 +353,17 @@ class CO2Leakage(WebvizPluginABC):
                 }
                 for i, d in enumerate(date_list)
             }
-            initial_date = max(dates.keys())
-            return dates, initial_date
+            return dates, max(dates.keys())
 
         @callback(
             Output(self._view_component(MapViewElement.Ids.DATE_WRAPPER), "style"),
             Input(self._settings_component(ViewSettings.Ids.PROPERTY), "value"),
         )
         def toggle_date_slider(attribute: str) -> Dict[str, str]:
-            if MapAttribute(attribute) == MapAttribute.MIGRATION_TIME:
+            if MapAttribute(attribute) in [
+                MapAttribute.MIGRATION_TIME_SGAS,
+                MapAttribute.MIGRATION_TIME_AMFG,
+            ]:
                 return {"display": "none"}
             return {}
 
@@ -401,7 +404,7 @@ class CO2Leakage(WebvizPluginABC):
             )
 
         # Cannot avoid many arguments and/or locals since all layers of the DeckGL map
-        # needs to be updated simultaneously
+        # need to be updated simultaneously
         # pylint: disable=too-many-arguments,too-many-locals
         @callback(
             Output(self._view_component(MapViewElement.Ids.DECKGL_MAP), "layers"),
@@ -512,7 +515,6 @@ class CO2Leakage(WebvizPluginABC):
                 self._summed_co2,
                 self._visualization_info["unit"],
             )
-            # Plume polygon
             plume_polygon = None
             if contour_data is not None:
                 plume_polygon = get_plume_polygon(
@@ -566,3 +568,43 @@ class CO2Leakage(WebvizPluginABC):
             if _n_clicks is not None:
                 return _n_clicks > 0
             raise PreventUpdate
+
+        @callback(
+            Output(self._view_component(MapViewElement.Ids.TOP_ELEMENT), "style"),
+            Output(self._view_component(MapViewElement.Ids.BOTTOM_ELEMENT), "style"),
+            Output(self._view_component(MapViewElement.Ids.BAR_PLOT), "style"),
+            Output(self._view_component(MapViewElement.Ids.TIME_PLOT), "style"),
+            Output(
+                self._view_component(MapViewElement.Ids.TIME_PLOT_ONE_REAL), "style"
+            ),
+            Input(self._settings_component(ViewSettings.Ids.ENSEMBLE), "value"),
+            Input(self._view_component(MapViewElement.Ids.SIZE_SLIDER), "value"),
+            State(self._view_component(MapViewElement.Ids.TOP_ELEMENT), "style"),
+            State(self._view_component(MapViewElement.Ids.BOTTOM_ELEMENT), "style"),
+            Input(self._settings_component(ViewSettings.Ids.GRAPH_SOURCE), "value"),
+        )
+        def resize_plots(
+            ensemble: str,
+            slider_value: float,
+            top_style: Dict,
+            bottom_style: Dict,
+            source: GraphSource,
+        ) -> List[Dict]:
+            bottom_style["height"] = f"{slider_value}vh"
+            top_style["height"] = f"{80 - slider_value}vh"
+
+            styles = [{"height": f"{slider_value * 0.9 - 4}vh", "width": "90%"}] * 3
+            if source == GraphSource.UNSMRY and self._unsmry_providers is None:
+                styles = [{"display": "none"}] * 3
+            elif (
+                source == GraphSource.CONTAINMENT_MASS
+                and ensemble not in self._co2_table_providers
+            ):
+                styles = [{"display": "none"}] * 3
+            elif (
+                source == GraphSource.CONTAINMENT_ACTUAL_VOLUME
+                and ensemble not in self._co2_actual_volume_table_providers
+            ):
+                styles = [{"display": "none"}] * 3
+
+            return [top_style, bottom_style] + styles

webviz_subsurface/plugins/_co2_leakage/_utilities/callbacks.py

@@ -6,6 +6,7 @@ import geojson
 import numpy as np
 import plotly.graph_objects as go
 import webviz_subsurface_components as wsc
+from dash import no_update
 from flask_caching import Cache
 
 from webviz_subsurface._providers import (
@@ -30,7 +31,6 @@ from webviz_subsurface.plugins._co2_leakage._utilities.co2volume import (
 from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
     Co2MassScale,
     Co2VolumeScale,
-    ContainmentViews,
     GraphSource,
     LayoutLabels,
     MapAttribute,
@@ -56,7 +56,7 @@ def property_origin(
         return map_attribute_names[MapAttribute.MAX_SGAS]
     if attribute == MapAttribute.AMFG_PLUME:
         return map_attribute_names[MapAttribute.MAX_AMFG]
-    raise AssertionError(f"No origin defined for property: {attribute}")
+    raise AssertionError(f"Map attribute name not found for property: {attribute}")
 
 
 @dataclass
@@ -86,7 +86,9 @@ class SurfaceData:
             visualization_info,
             map_attribute_names,
         )
-        assert surf_meta is not None  # Should not occur
+        if surf_meta is None:  # Surface file does not exist
+            return None, None
+        assert isinstance(img_url, str)
         value_range = (
             0.0 if np.ma.is_masked(surf_meta.val_min) else surf_meta.val_min,
             0.0 if np.ma.is_masked(surf_meta.val_max) else surf_meta.val_max,
@@ -132,7 +134,15 @@ def derive_surface_address(
             threshold=contour_data["threshold"] if contour_data else 0.0,
             smoothing=contour_data["smoothing"] if contour_data else 0.0,
         )
-    date = None if attribute == MapAttribute.MIGRATION_TIME else date
+    date = (
+        None
+        if attribute
+        in [
+            MapAttribute.MIGRATION_TIME_SGAS,
+            MapAttribute.MIGRATION_TIME_AMFG,
+        ]
+        else date
+    )
     if len(realization) == 1:
         return SimulatedSurfaceAddress(
             attribute=map_attribute_names[attribute],
@@ -151,7 +161,10 @@ def derive_surface_address(
 
 def readable_name(attribute: MapAttribute) -> str:
     unit = ""
-    if attribute == MapAttribute.MIGRATION_TIME:
+    if attribute in [
+        MapAttribute.MIGRATION_TIME_SGAS,
+        MapAttribute.MIGRATION_TIME_AMFG,
+    ]:
         unit = " [year]"
     elif attribute in (MapAttribute.AMFG_PLUME, MapAttribute.SGAS_PLUME):
         unit = " [# real.]"
@@ -198,7 +211,10 @@ def get_plume_polygon(
 
 
 def _find_legend_title(attribute: MapAttribute, unit: str) -> str:
-    if attribute == MapAttribute.MIGRATION_TIME:
+    if attribute in [
+        MapAttribute.MIGRATION_TIME_SGAS,
+        MapAttribute.MIGRATION_TIME_AMFG,
+    ]:
         return "years"
     if attribute in [MapAttribute.MASS, MapAttribute.DISSOLVED, MapAttribute.FREE]:
         return unit
@@ -213,7 +229,13 @@ def create_map_annotations(
     unit: str,
 ) -> List[wsc.ViewAnnotation]:
     annotations = []
-    if surface_data is not None:
+    if (
+        surface_data is not None
+        and surface_data.color_map_range[0] is not None
+        and surface_data.color_map_range[1] is not None
+    ):
+        num_digits = np.ceil(np.log(surface_data.color_map_range[1]) / np.log(10))
+        numbersize = max((6, min((17 - num_digits, 11))))
         annotations.append(
             wsc.ViewAnnotation(
                 id="1_view",
@@ -227,6 +249,8 @@ def create_map_annotations(
                         openColorSelector=False,
                         legendScaleSize=0.1,
                         legendFontSize=20,
+                        tickFontSize=numbersize,
+                        numberOfTicks=2,
                         colorTables=colortables,
                     ),
                     wsc.ViewFooter(children=formation),
@@ -383,7 +407,7 @@ def generate_containment_figures(
     co2_scale: Union[Co2MassScale, Co2VolumeScale],
     realization: int,
     y_limits: List[Optional[float]],
-    containment_info: Dict[str, Union[str, None, List[str]]],
+    containment_info: Dict[str, Union[str, None, List[str], int]],
 ) -> Tuple[go.Figure, go.Figure, go.Figure]:
     try:
         fig0 = generate_co2_volume_figure(
@@ -484,36 +508,73 @@ def process_visualization_info(
 def process_containment_info(
     zone: Optional[str],
     region: Optional[str],
-    view: Optional[str],
-    zone_and_region_options: Dict[str, List[str]],
-    source: str,
-) -> Dict[str, Union[str, None, List[str]]]:
-    zones = zone_and_region_options["zones"]
-    regions = zone_and_region_options["regions"]
-    if source in [
-        GraphSource.CONTAINMENT_MASS,
-        GraphSource.CONTAINMENT_ACTUAL_VOLUME,
-    ]:
-        if view == ContainmentViews.CONTAINMENTSPLIT:
-            return {"zone": zone, "region": region, "containment_view": view}
-        if view == ContainmentViews.ZONESPLIT and len(zones) > 0:
-            zones = [zone_name for zone_name in zones if zone_name != "all"]
-        elif view == ContainmentViews.REGIONSPLIT and len(regions) > 0:
-            regions = [reg_name for reg_name in regions if reg_name != "all"]
-        else:
-            return {
-                "zone": zone,
-                "region": region,
-                "containment_view": ContainmentViews.CONTAINMENTSPLIT,
-            }
-        return {
-            "zone": zone,
-            "region": region,
-            "containment_view": view,
-            "zones": zones,
-            "regions": regions,
-        }
-    return {"containment_view": ContainmentViews.CONTAINMENTSPLIT}
+    phase: str,
+    containment: str,
+    color_choice: str,
+    mark_choice: Optional[str],
+    sorting: str,
+    menu_options: Dict[str, List[str]],
+) -> Dict[str, Union[str, None, List[str], int]]:
+    if mark_choice is None:
+        mark_choice = "phase"
+    zones = menu_options["zones"]
+    regions = menu_options["regions"]
+    if len(zones) > 0:
+        zones = [zone_name for zone_name in zones if zone_name != "all"]
+    if len(regions) > 0:
+        regions = [reg_name for reg_name in regions if reg_name != "all"]
+    containments = ["hazardous", "outside", "contained"]
+    phases = [phase for phase in menu_options["phases"] if phase != "total"]
+    if "zone" in [mark_choice, color_choice]:
+        region = "all"
+    if "region" in [mark_choice, color_choice]:
+        zone = "all"
+    return {
+        "zone": zone,
+        "region": region,
+        "zones": zones,
+        "regions": regions,
+        "phase": phase,
+        "containment": containment,
+        "color_choice": color_choice,
+        "mark_choice": mark_choice,
+        "sorting": sorting,
+        "phases": phases,
+        "containments": containments,
+    }
+
+
+def set_plot_ids(
+    figs: List[go.Figure],
+    source: GraphSource,
+    scale: Union[Co2MassScale, Co2VolumeScale],
+    containment_info: Dict,
+    realizations: List[int],
+) -> None:
+    if figs[0] != no_update:
+        zone_str = (
+            containment_info["zone"] if containment_info["zone"] is not None else "None"
+        )
+        region_str = (
+            containment_info["region"]
+            if containment_info["region"] is not None
+            else "None"
+        )
+        plot_id = "-".join(
+            (
+                source,
+                scale,
+                zone_str,
+                region_str,
+                str(containment_info["phase"]),
+                str(containment_info["containment"]),
+                containment_info["color_choice"],
+                containment_info["mark_choice"],
+            )
+        )
+        for fig in figs:
+            fig["layout"]["uirevision"] = plot_id
+        figs[-1]["layout"]["uirevision"] += f"-{realizations}"
 
 
 def process_summed_mass(