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

webviz_subsurface/_datainput/well_completions.py

@@ -69,7 +69,7 @@ def read_zone_layer_mapping(
         )
         df_real["K1"] = df_real.index
         df_real["REAL"] = real
-        zonelist = remove_invalid_colors(zonelist)
+        zonelist = remove_invalid_colors(zonelist) if zonelist else []
         zone_color_mapping = {
             zonedict["name"]: zonedict["color"]
             for zonedict in zonelist

webviz_subsurface/_models/gruptree_model.py

@@ -191,16 +191,13 @@ GruptreeDataModel({self._ens_name!r}, {self._ens_path!r}, {self._gruptree_file!r
                     raise ValueError(
                         f"Keyword {self._tree_type.value} not found in {row['FULLPATH']}"
                     )
+
+                # Only filter if both tree types are present
                 if (
-                    self._tree_type == TreeType.GRUPTREE
+                    TreeType.GRUPTREE.value in unique_keywords
                     and TreeType.BRANPROP.value in unique_keywords
                 ):
-                    # Filter out BRANPROP entries
-                    df_real = df_real[df_real["KEYWORD"] != TreeType.BRANPROP.value]
-
-                if self._tree_type == TreeType.BRANPROP:
-                    # Filter out GRUPTREE entries
-                    df_real = df_real[df_real["KEYWORD"] != TreeType.GRUPTREE.value]
+                    df_real = self._filter_by_tree_type(df_real, self._tree_type)
 
             if (
                 i > 0
@@ -222,3 +219,30 @@ GruptreeDataModel({self._ens_name!r}, {self._ens_path!r}, {self._gruptree_file!r
         df["DATE"] = pd.to_datetime(df["DATE"])
 
         return df.where(pd.notnull(df), None)
+
+    @staticmethod
+    def _filter_by_tree_type(df: pd.DataFrame, tree_type: TreeType) -> pd.DataFrame:
+        """
+        Filter dataframe to include only dates where the selected tree type is defined,
+        and only include WELSPECS nodes that belong to the selected tree type.
+
+        A WELSPECS node belongs to a tree if its parent node exists in that tree's definition.
+        """
+        # Find dates where the selected tree type is defined
+        dates_with_tree_type = df[df["KEYWORD"] == tree_type.value]["DATE"].unique()
+
+        # Filter to only include rows from those dates
+        df = df[df["DATE"].isin(dates_with_tree_type)].copy()
+
+        # Get all nodes that are defined in the selected tree type (across all dates)
+        tree_nodes = set(df[df["KEYWORD"] == tree_type.value]["CHILD"].unique())
+
+        # Keep rows that are:
+        # 1. The selected tree type itself (GRUPTREE or BRANPROP)
+        # 2. WELSPECS whose parent exists in the selected tree type
+        is_selected_tree = df["KEYWORD"] == tree_type.value
+        is_welspecs_with_valid_parent = (df["KEYWORD"] == "WELSPECS") & df[
+            "PARENT"
+        ].isin(tree_nodes)
+
+        return df[is_selected_tree | is_welspecs_with_valid_parent].copy()

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.43'
-__version_tuple__ = version_tuple = (0, 2, 43)
+__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(