webviz-subsurface 0.2.44__py3-none-any.whl → 0.2.46__py3-none-any.whl

webviz_subsurface/_providers/ensemble_polygon_provider/_provider_impl_file.py

@@ -33,7 +33,8 @@ class Col:
 
 class PolygonType(StrEnum):
     SIMULATED = "simulated"
-    HAZARDUOUS_BOUNDARY = "hazarduous_boundary"
+    HAZARDOUS_BOUNDARY = "hazardous_boundary"  # Keep for backward compatibility
+    NOGO_BOUNDARY = "nogo_boundary"
     CONTAINMENT_BOUNDARY = "containment_boundary"
 
 

webviz_subsurface/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.44'
-__version_tuple__ = version_tuple = (0, 2, 44)
+__version__ = version = '0.2.46'
+__version_tuple__ = version_tuple = (0, 2, 46)
 
 __commit_id__ = commit_id = None

webviz_subsurface/plugins/_co2_migration/_plugin.py

@@ -40,6 +40,8 @@ from webviz_subsurface.plugins._co2_migration._utilities.generic import (
     MapAttribute,
     MapThresholds,
     MapType,
+    check_hazardous_polygon,
+    deactivate_polygon_warnings,
 )
 from webviz_subsurface.plugins._co2_migration._utilities.initialization import (
     init_containment_data_providers,
@@ -95,7 +97,7 @@ class CO2Migration(WebvizPluginABC):
     * **`map_surface_names_to_fault_polygons`:** Mapping between surface map names and
         surface names used by the fault polygons
     * **`boundary_settings`:** Settings for polygons representing the containment and
-        hazardous areas
+        nogo areas
     ---
 
     This plugin is tightly linked to the FMU CCS post-process available in the ccs-scripts
@@ -141,17 +143,17 @@ class CO2Migration(WebvizPluginABC):
     Similar for `map_surface_names_to_fault_polygons`.
 
     `boundary_settings` is the final override option, and it can be used to specify
-    polygons representing the containment and hazardous areas. By default, the polygons are
+    polygons representing the containment and nogo areas. By default, the polygons are
     expected to be named:
     - `share/results/polygons/containment--boundary.csv`
-    - `share/results/polygons/hazarduous--boundary.csv`
+    - `share/results/polygons/nogo--boundary.csv`
 
     This corresponds to the following input:
     ```
     boundary_settings:
       polygon_file_pattern: share/results/polygons/*.csv
       attribute: boundary
-      hazardous_name: hazardous
+      nogo_name: nogo
       containment_name: containment
     ```
     All four settings are optional, and if not specified, the default values are used.
@@ -182,6 +184,8 @@ class CO2Migration(WebvizPluginABC):
         super().__init__()
         self._error_message = ""
         try:
+            deactivate_polygon_warnings()
+            check_hazardous_polygon(boundary_settings)
             ensemble_paths = {
                 ensemble_name: webviz_settings.shared_settings["scratch_ensembles"][
                     ensemble_name
@@ -435,6 +439,13 @@ class CO2Migration(WebvizPluginABC):
                 "cm_max_val": Input(
                     self._settings_component(ViewSettings.Ids.CM_MAX), "value"
                 ),
+                "contour_switch": Input(
+                    self._settings_component(ViewSettings.Ids.CONTOURS_SWITCH), "value"
+                ),
+                "contour_quantity": Input(
+                    self._settings_component(ViewSettings.Ids.CONTOURS_QUANTITY),
+                    "value",
+                ),
                 "plume_threshold": Input(
                     self._settings_component(ViewSettings.Ids.PLUME_THRESHOLD),
                     "value",
@@ -480,12 +491,14 @@ class CO2Migration(WebvizPluginABC):
             cm_min_val: Optional[float],
             cm_max_auto: List[str],
             cm_max_val: Optional[float],
+            contour_switch: List[str],
+            contour_quantity: Optional[float],
             plume_threshold: Optional[float],
             plume_smoothing: Optional[float],
             visualization_update: int,
             mass_unit: str,
             mass_unit_update: int,
-            options_dialog_options: List[int],
+            options_dialog_options: List[str],
             selected_wells: List[str],
             ensemble: str,
             current_views: List[Any],
@@ -545,13 +558,12 @@ class CO2Migration(WebvizPluginABC):
                     map_attribute_names=self._map_attribute_names,
                 )
             assert isinstance(self._visualization_info["unit"], str)
-            surf_data, self._summed_co2 = process_summed_mass(
+            current_summed_mass, self._summed_co2 = process_summed_mass(
                 formation,
                 realization,
                 datestr,
                 attribute,
                 summed_mass,
-                surf_data,
                 self._summed_co2,
                 self._visualization_info["unit"],
             )
@@ -568,6 +580,9 @@ class CO2Migration(WebvizPluginABC):
             fault_polygon_url = self._fault_polygon_handlers[
                 ensemble
             ].extract_fault_polygon_url(formation, realization)
+            nogo_polygon_url = self._polygon_handlers[ensemble].extract_nogo_poly_url(
+                realization
+            )
             hazardous_polygon_url = self._polygon_handlers[
                 ensemble
             ].extract_hazardous_poly_url(realization)
@@ -580,11 +595,14 @@ class CO2Migration(WebvizPluginABC):
                 surface_data=surf_data,
                 fault_polygon_url=fault_polygon_url,
                 containment_bounds_url=containment_polygon_url,
-                haz_bounds_url=hazardous_polygon_url,
+                nogo_bounds_url=nogo_polygon_url,
+                hazardous_bounds_url=hazardous_polygon_url,
                 well_pick_provider=self._well_pick_provider.get(ensemble, None),
                 plume_extent_data=plume_polygon,
                 options_dialog_options=options_dialog_options,
                 selected_wells=selected_wells,
+                show_contours=len(contour_switch) > 0,
+                num_contours=contour_quantity,
             )
             annotations = create_map_annotations(
                 formation=formation,
@@ -592,6 +610,11 @@ class CO2Migration(WebvizPluginABC):
                 colortables=self._color_tables,
                 attribute=attribute,
                 unit=self._visualization_info["unit"],
+                current_total=current_summed_mass,
+                options=options_dialog_options,
+                con_url=containment_polygon_url,
+                haz_url=hazardous_polygon_url,
+                nogo_url=nogo_polygon_url,
             )
             viewports = no_update if current_views else create_map_viewports()
             return layers, annotations, viewports

webviz_subsurface/plugins/_co2_migration/_utilities/callbacks.py

@@ -7,7 +7,7 @@ import geojson
 import numpy as np
 import plotly.graph_objects as go
 import webviz_subsurface_components as wsc
-from dash import dcc, no_update
+from dash import dcc, html, no_update
 from flask_caching import Cache
 
 from webviz_subsurface._providers import (
@@ -234,12 +234,127 @@ def _find_legend_title(attribute: MapAttribute, unit: str) -> str:
     return ""
 
 
+def _create_summed_mass_annotation(
+    attribute: MapAttribute,
+    summed_mass: Optional[float],
+    unit: str,
+) -> Union[str, tuple]:
+    annotation = (
+        html.P(
+            [
+                f"Total {MapAttribute[attribute.name].value.lower()}:",
+                html.Br(),
+                f"{summed_mass:.2f} {unit}",
+            ]
+        )
+        if MapType[attribute.name].value == "MASS" and summed_mass is not None
+        else ""
+    )
+    return html.Div(
+        annotation,
+        style={
+            "position": "absolute",
+            "top": "210px",
+            "right": "4px",
+            "backgroundColor": "rgba(255,255,255,0.8)",
+            "padding": "1px 1px",
+            "fontWeight": "bold",
+            "fontSize": "15px",
+            "display": "block",
+        },
+    )
+
+
+def _create_polygon_legend(
+    options: List[str],
+    con_url: Optional[str],
+    haz_url: Optional[str],  # Keep for backward compatibility
+    nogo_url: Optional[str],
+) -> List:
+    legend: List = []
+    hide_con = con_url is None or LayoutLabels.SHOW_CONTAINMENT_POLYGON not in options
+    hide_nogo = (
+        nogo_url is None and haz_url is None
+    ) or LayoutLabels.SHOW_NOGO_POLYGON not in options
+    outline = LayoutLabels.SHOW_POLYGONS_AS_OUTLINES in options
+    if hide_con and hide_nogo:
+        return legend
+    legend_items = []
+    square = {"width": "12px", "height": "12px", "marginRight": "6px"}
+    text = {"color": "black", "fontSize": "14px"}
+    if not hide_con:
+        legend_items.append(
+            html.Div(
+                style={"display": "flex", "alignItems": "center"},
+                children=[
+                    html.Div(
+                        style={
+                            **square,
+                            "backgroundColor": "transparent"
+                            if outline
+                            else "rgba(0, 172, 0, 0.47)",
+                            "border": "3px solid rgba(0, 172, 0, 0.70)"
+                            if outline
+                            else "transparent",
+                        }
+                    ),
+                    html.Div("Containment Polygon", style=text),
+                ],
+            )
+        )
+    if not hide_nogo:
+        legend_items.append(
+            html.Div(
+                style={"display": "flex", "alignItems": "center"},
+                children=[
+                    html.Div(
+                        style={
+                            **square,
+                            "backgroundColor": "transparent"
+                            if outline
+                            else "rgba(200, 0, 0, 0.47)",
+                            "border": "3px solid rgba(200, 0, 0, 0.70)"
+                            if outline
+                            else "transparent",
+                        }
+                    ),
+                    html.Div("No-go Polygon", style=text),
+                ],
+            )
+        )
+    legend.append(
+        wsc.ViewAnnotation(
+            id="polygon_legends",
+            children=html.Div(
+                children=legend_items,
+                style={
+                    "position": "absolute",
+                    "top": "50px",
+                    "left": "4px",
+                    "backgroundColor": "rgba(255,255,255,0.9)",
+                    "padding": "6px 8px",
+                    "borderRadius": "4px",
+                    "boxShadow": "0 0 4px rgba(0,0,0,0.2)",
+                    "zIndex": 10,
+                },
+            ),
+        )
+    )
+    return legend
+
+
+# pylint: disable=too-many-arguments, too-many-locals
 def create_map_annotations(
     formation: str,
     surface_data: Optional[SurfaceData],
     colortables: List[Dict[str, Any]],
     attribute: MapAttribute,
     unit: str,
+    current_total: Optional[float],
+    options: List[str],
+    con_url: Optional[str],
+    haz_url: Optional[str],
+    nogo_url: Optional[str],
 ) -> List[wsc.ViewAnnotation]:
     annotations = []
     if (
@@ -268,7 +383,9 @@ def create_map_annotations(
                         colorTables=colortables,
                     ),
                     wsc.ViewFooter(children=formation),
-                ],
+                    _create_summed_mass_annotation(attribute, current_total, unit),
+                ]
+                + _create_polygon_legend(options, con_url, haz_url, nogo_url),
             )
         )
     return annotations
@@ -286,7 +403,8 @@ def create_map_viewports() -> Dict:
                     "colormap-layer",
                     "fault-polygons-layer",
                     "license-boundary-layer",
-                    "hazardous-boundary-layer",
+                    "nogo-boundary-layer",
+                    "hazardous-boundary-layer",  # Keep for backward compatibility
                     "well-picks-layer",
                     "plume-polygon-layer",
                 ],
@@ -302,16 +420,35 @@ def create_map_layers(
     surface_data: Optional[SurfaceData],
     fault_polygon_url: Optional[str],
     containment_bounds_url: Optional[str],
-    haz_bounds_url: Optional[str],
+    nogo_bounds_url: Optional[str],
+    hazardous_bounds_url: Optional[str],  # Keep for backward compatibility
     well_pick_provider: Optional[EnsembleWellPicks],
     plume_extent_data: Optional[geojson.FeatureCollection],
-    options_dialog_options: List[int],
+    options_dialog_options: List[str],
     selected_wells: List[str],
+    show_contours: bool,
+    num_contours: Optional[float],
 ) -> List[Dict]:
     layers = []
+    outline = LayoutLabels.SHOW_POLYGONS_AS_OUTLINES in options_dialog_options
     if surface_data is not None:
         # Update ColormapLayer
         meta = surface_data.meta_data
+
+        # Generate contour lines
+        contours = []
+        if (
+            show_contours
+            and surface_data.color_map_range[0] is not None
+            and surface_data.color_map_range[1] is not None
+            and num_contours is not None
+        ):
+            min_val, max_val = surface_data.color_map_range
+            assert min_val is not None and max_val is not None
+            buffer = 0.01 * (max_val - min_val)  # Strange effects at min_val/max_val
+            step = (max_val - min_val + 2 * buffer) / (np.round(num_contours) + 1)
+            contours = [min_val + step - buffer, step]
+
         layers.append(
             {
                 "@@type": "MapLayer",
@@ -327,6 +464,7 @@ def create_map_layers(
                 "colorMapName": surface_data.color_map_name,
                 "colorMapRange": surface_data.color_map_range,
                 "material": False,
+                "contours": contours,
             }
         )
 
@@ -353,24 +491,52 @@ def create_map_layers(
                 "name": "Containment Polygon",
                 "id": "license-boundary-layer",
                 "data": containment_bounds_url,
-                "stroked": False,
+                "stroked": outline,
+                "filled": not outline,
                 "getFillColor": [0, 172, 0, 120],
+                "getLineColor": [0, 172, 0, 120],
+                "getLineWidth": 3,
+                "lineWidthUnits": "pixels",
+                "visible": True,
+            }
+        )
+
+    if (
+        nogo_bounds_url is not None
+        and LayoutLabels.SHOW_NOGO_POLYGON in options_dialog_options
+    ):
+        layers.append(
+            {
+                "@@type": "GeoJsonLayer",
+                "name": "No-go Polygon",
+                "id": "nogo-boundary-layer",
+                "data": nogo_bounds_url,
+                "stroked": outline,
+                "filled": not outline,
+                "getFillColor": [200, 0, 0, 120],
+                "getLineColor": [200, 0, 0, 180],
+                "getLineWidth": 3,
+                "lineWidthUnits": "pixels",
                 "visible": True,
             }
         )
 
     if (
-        haz_bounds_url is not None
-        and LayoutLabels.SHOW_HAZARDOUS_POLYGON in options_dialog_options
+        hazardous_bounds_url is not None
+        and LayoutLabels.SHOW_NOGO_POLYGON in options_dialog_options
     ):
         layers.append(
             {
                 "@@type": "GeoJsonLayer",
-                "name": "Hazardous Polygon",
+                "name": "No-go Polygon",
                 "id": "hazardous-boundary-layer",
-                "data": haz_bounds_url,
-                "stroked": False,
+                "data": hazardous_bounds_url,
+                "stroked": outline,
+                "filled": not outline,
                 "getFillColor": [200, 0, 0, 120],
+                "getLineColor": [200, 0, 0, 180],
+                "getLineWidth": 3,
+                "lineWidthUnits": "pixels",
                 "visible": True,
             }
         )
@@ -551,7 +717,7 @@ def process_containment_info(
         mark_choice=mark_choice,
         sorting=sorting,
         phases=[phase for phase in menu_options["phases"] if phase != "total"],
-        containments=["hazardous", "outside", "contained"],
+        containments=["nogo", "outside", "contained"],
         plume_groups=plume_groups,
         use_stats=lines_to_show == "stat",
         date_option=date_option,
@@ -631,20 +797,18 @@ def process_summed_mass(
     datestr: Optional[str],
     attribute: MapAttribute,
     summed_mass: Optional[float],
-    surf_data: Optional[SurfaceData],
     summed_co2: Dict[str, float],
     unit: str,
-) -> Tuple[Optional[SurfaceData], Dict[str, float]]:
+) -> Tuple[Optional[float], Dict[str, float]]:
     summed_co2_key = f"{formation}-{realization[0]}-{datestr}-{attribute}-{unit}"
+    current_total = None
     if len(realization) == 1:
         if MapType[MapAttribute(attribute).name].value == "MASS":
             if summed_mass is not None and summed_co2_key not in summed_co2:
                 summed_co2[summed_co2_key] = summed_mass
-            if summed_co2_key in summed_co2 and surf_data is not None:
-                surf_data.readable_name += (
-                    f" ({unit}) (Total: {summed_co2[summed_co2_key]:.2E}): "
-                )
-    return surf_data, summed_co2
+            if summed_co2_key in summed_co2:
+                current_total = summed_co2[summed_co2_key]
+    return current_total, summed_co2
 
 
 def export_figure_data_to_csv(

webviz_subsurface/plugins/_co2_migration/_utilities/co2volume.py

@@ -11,7 +11,6 @@ import pandas as pd
 import plotly.express as px
 import plotly.graph_objects as go
 
-from webviz_subsurface._providers import EnsembleTableProvider
 from webviz_subsurface._utils.enum_shim import StrEnum
 from webviz_subsurface.plugins._co2_migration._utilities.containment_data_provider import (
     ContainmentDataProvider,
@@ -32,19 +31,6 @@ class _Columns(StrEnum):
     VOLUME_OUTSIDE = "volume_outside"
 
 
-class Colors(StrEnum):
-    # pylint: disable=invalid-name
-    total = "#222222"
-    contained = "#00aa00"
-    outside = "#006ddd"
-    hazardous = "#dd4300"
-    dissolved_water = "#208eb7"
-    dissolved_oil = "#A0522D"
-    gas = "#C41E3A"
-    free_gas = "#FF2400"
-    trapped_gas = "#880808"
-
-
 class Marks(StrEnum):
     dissolved_water = "/"
     dissolved_oil = "x"
@@ -61,61 +47,76 @@ class Lines(StrEnum):
     trapped_gas = "dashdot"
 
 
-_COLOR_ZONES = [
-    "#e91451",
-    "#daa218",
-    "#208eb7",
-    "#84bc04",
-    "#b74532",
-    "#9a89b4",
-    "#8d30ba",
-    "#256b33",
-    "#95704d",
-    "#1357ca",
-    "#f75ef0",
-    "#34b36f",
+_CONTAINMENT_COLORS = {
+    "total": ("#222222", "#909090"),
+    "contained": ("#00aa00", "#55ff55"),
+    "outside": ("#006ddd", "#6eb6ff"),
+    "nogo": ("#dd4300", "#ff9a6e"),
+}
+
+
+_PHASE_COLORS = {
+    "total": ("#222222", "#909090"),
+    "dissolved_water": ("#208eb7", "#81cde9"),
+    "dissolved_oil": ("#A0522D", "#C28163"),
+    "gas": ("#C41E3A", "#E42E5A"),
+    "free_gas": ("#FF2400", "#FF7430"),
+    "trapped_gas": ("#880808", "#C84848"),
+}
+
+
+_GENERAL_COLORS = [
+    ("#e91451", "#f589a8"),
+    ("#daa218", "#f2d386"),
+    ("#208eb7", "#81cde9"),
+    ("#84bc04", "#cdfc63"),
+    ("#b74532", "#e19e92"),
+    ("#9a89b4", "#ccc4d9"),
+    ("#8d30ba", "#c891e3"),
+    ("#256b33", "#77d089"),
+    ("#95704d", "#cfb7a1"),
+    ("#1357ca", "#7ba7f3"),
+    ("#f75ef0", "#fbaef7"),
+    ("#34b36f", "#93e0b7"),
 ]
 
+
 _LIGHTER_COLORS = {
     "black": "#909090",
-    "#222222": "#909090",
-    "#00aa00": "#55ff55",
-    "#006ddd": "#6eb6ff",
-    "#dd4300": "#ff9a6e",
-    "#e91451": "#f589a8",
-    "#daa218": "#f2d386",
-    "#208eb7": "#81cde9",
-    "#84bc04": "#cdfc63",
-    "#b74532": "#e19e92",
-    "#9a89b4": "#ccc4d9",
-    "#8d30ba": "#c891e3",
-    "#256b33": "#77d089",
-    "#95704d": "#cfb7a1",
-    "#1357ca": "#7ba7f3",
-    "#f75ef0": "#fbaef7",
-    "#34b36f": "#93e0b7",
-    "#C41E3A": "#E42E5A",
-    "#FF2400": "#FF7430",
-    "#880808": "#C84848",
+    **dict(_CONTAINMENT_COLORS.values()),
+    **dict(_PHASE_COLORS.values()),
+    **dict(_GENERAL_COLORS),
 }
 
+_LABEL_TRANSLATIONS = {
+    "nogo": "no-go",
+    "dissolved_water": "dissolved water",
+    "dissolved_oil": "dissolved oil",
+    "free_gas": "free gas",
+    "trapped_gas": "trapped gas",
+}
 
-def _read_dataframe(
-    table_provider: EnsembleTableProvider,
-    realization: int,
-    scale_factor: float,
-) -> pd.DataFrame:
-    df = table_provider.get_column_data(table_provider.column_names(), [realization])
-    if scale_factor == 1.0:
-        return df
-    df["amount"] /= scale_factor
-    return df
+
+def _translate_labels(df: Union[pd.DataFrame, Dict], column: str = "type") -> None:
+    def translate_label(label: str) -> str:
+        if ", " in label:
+            parts = label.split(", ")
+            translated_parts = [_LABEL_TRANSLATIONS.get(part, part) for part in parts]
+            return ", ".join(translated_parts)
+        return _LABEL_TRANSLATIONS.get(label, label)
+
+    if isinstance(df, dict):
+        df[column] = [translate_label(label) for label in df[column]]
+    else:
+        df[column] = df[column].apply(translate_label)
 
 
 def _get_colors(color_options: List[str], split: str) -> List[str]:
-    if split in {"containment", "phase"}:
-        return [Colors[option] for option in color_options]
-    options = list(_COLOR_ZONES)
+    if split == "containment":
+        return [_CONTAINMENT_COLORS[option][0] for option in color_options]
+    if split == "phase":
+        return [_PHASE_COLORS[option][0] for option in color_options]
+    options = [x[0] for x in _GENERAL_COLORS]
     if split == "region":
         options.reverse()
     num_cols = len(color_options)
@@ -268,8 +269,8 @@ def _prepare_pattern_and_color_options_statistics_plot(
 
 
 def _find_default_legendonly(df: pd.DataFrame, categories: List[str]) -> List[str]:
-    if "hazardous" in categories:
-        default_option = "hazardous"
+    if "no-go" in categories:
+        default_option = "no-go"
     else:
         max_value = -999.9
         default_option = categories[0]
@@ -416,7 +417,7 @@ def _add_sort_key_and_real(
     sort_value = np.sum(
         df[
             (df["phase"] == "total")
-            & (df["containment"] == "hazardous")
+            & (df["containment"] == "nogo")
             & (df["zone"] == containment_info.zone)
             & (df["region"] == containment_info.region)
             & (df["plume_group"] == containment_info.plume_group)
@@ -530,6 +531,9 @@ def generate_co2_volume_figure(
         color_choice,
         mark_choice,
     )
+    _translate_labels(df, "type")
+    _translate_labels(cat_ord, "type")
+
     fig = px.bar(
         df,
         y="real",
@@ -590,6 +594,9 @@ def generate_co2_time_containment_one_realization_figure(
         color_choice,
         mark_choice,
     )
+    _translate_labels(df, "type")
+    _translate_labels(cat_ord, "type")
+
     fig = px.area(
         df,
         x="date",
@@ -776,6 +783,8 @@ def generate_co2_time_containment_figure(
     options = _prepare_line_type_and_color_options(
         df, containment_info, color_choice, mark_choice
     )
+    _translate_labels(df, "name")
+    _translate_labels(options, "name")
     if legendonly_traces is None:
         inactive_cols_at_startup = list(
             options[~(options["line_type"].isin(["solid", "0px"]))]["name"]
@@ -788,6 +797,14 @@ def generate_co2_time_containment_figure(
         except ValueError:
             pass
 
+    options["name"] = options["name"].apply(
+        lambda label: ", ".join(
+            [_LABEL_TRANSLATIONS.get(part, part) for part in label.split(", ")]
+        )
+        if ", " in label
+        else _LABEL_TRANSLATIONS.get(label, label)
+    )
+
     fig = go.Figure()
     # Generate dummy scatters for legend entries
     dummy_args = {"x": df["date"], "mode": "lines", "hoverinfo": "none"}
@@ -907,6 +924,8 @@ def generate_co2_statistics_figure(
         color_choice,
         mark_choice,
     )
+    _translate_labels(df, "type")
+    _translate_labels(cat_ord, "type")
 
     df = df.drop(columns=["REAL"]).reset_index(drop=True)
     fig = px.ecdf(
@@ -973,6 +992,8 @@ def generate_co2_box_plot_figure(
         color_choice,
         mark_choice,
     )
+    _translate_labels(df, "type")
+    _translate_labels(cat_ord, "type")
 
     fig = go.Figure()
     for count, type_val in enumerate(cat_ord["type"], 0):