webviz-subsurface 0.2.36__py3-none-any.whl → 0.2.38__py3-none-any.whl

webviz_subsurface/plugins/_co2_leakage/_utilities/containment_data_provider.py

@@ -0,0 +1,147 @@
+from typing import List, Optional, Union
+
+import pandas as pd
+
+from webviz_subsurface._providers import EnsembleTableProvider
+from webviz_subsurface.plugins._co2_leakage._utilities.generic import (
+    Co2MassScale,
+    Co2VolumeScale,
+    MenuOptions,
+)
+
+
+class ContainmentDataValidationError(Exception):
+    pass
+
+
+class ContainmentDataProvider:
+    def __init__(self, table_provider: EnsembleTableProvider):
+        ContainmentDataProvider._validate(table_provider)
+        self._provider = table_provider
+        self._menu_options = ContainmentDataProvider._get_menu_options(self._provider)
+
+    @property
+    def menu_options(self) -> MenuOptions:
+        return self._menu_options
+
+    @property
+    def realizations(self) -> List[int]:
+        return self._provider.realizations()
+
+    def extract_dataframe(
+        self, realization: int, scale: Union[Co2MassScale, Co2VolumeScale]
+    ) -> pd.DataFrame:
+        df = self._provider.get_column_data(
+            self._provider.column_names(), [realization]
+        )
+        scale_factor = self._find_scale_factor(scale)
+        if scale_factor == 1.0:
+            return df
+        df["amount"] /= scale_factor
+        return df
+
+    def extract_condensed_dataframe(
+        self,
+        co2_scale: Union[Co2MassScale, Co2VolumeScale],
+    ) -> pd.DataFrame:
+        df = self._provider.get_column_data(self._provider.column_names())
+        df = df.loc[
+            (df["zone"] == "all")
+            & (df["region"] == "all")
+            & (df["plume_group"] == "all")
+        ]
+        if co2_scale == Co2MassScale.MTONS:
+            df.loc[:, "amount"] /= 1e9
+        elif co2_scale == Co2MassScale.NORMALIZE:
+            df.loc[:, "amount"] /= df["amount"].max()
+        return df
+
+    def _find_scale_factor(
+        self,
+        scale: Union[Co2MassScale, Co2VolumeScale],
+    ) -> float:
+        if scale == Co2MassScale.KG:
+            return 0.001
+        if scale in (Co2MassScale.TONS, Co2VolumeScale.CUBIC_METERS):
+            return 1.0
+        if scale == Co2MassScale.MTONS:
+            return 1e6
+        if scale == Co2VolumeScale.BILLION_CUBIC_METERS:
+            return 1e9
+        if scale in (Co2MassScale.NORMALIZE, Co2VolumeScale.NORMALIZE):
+            df = self._provider.get_column_data(["amount"])
+            return df["amount"].max()
+        return 1.0
+
+    @staticmethod
+    def _get_menu_options(provider: EnsembleTableProvider) -> MenuOptions:
+        col_names = provider.column_names()
+        realization = provider.realizations()[0]
+        # NBNB: Check that these are the same for all realizations????
+        # NBNB: WARNING and empty for zones / regions, and Error if phases are different?
+        df = provider.get_column_data(col_names, [realization])
+        zones = ["all"]
+        if "zone" in df:
+            for zone in list(df["zone"]):
+                if zone not in zones:
+                    zones.append(zone)
+        regions = ["all"]
+        if "region" in df:
+            for region in list(df["region"]):
+                if region not in regions:
+                    regions.append(region)
+        plume_groups = ["all"]
+        if "plume_group" in df:
+            for plume_group in list(df["plume_group"]):
+                if plume_group not in plume_groups and plume_group is not None:
+                    plume_groups.append(plume_group)
+
+        def plume_sort_key(name: Optional[str]) -> int:
+            if name is None:
+                return 999  # Not sure why/when this can happen, just a precaution
+            if name == "undetermined":
+                return 998
+            return name.count("+")
+
+        plume_groups = sorted(plume_groups, key=plume_sort_key)
+
+        if "free_gas" in list(df["phase"]):
+            phases = ["total", "free_gas", "trapped_gas", "dissolved"]
+        else:
+            phases = ["total", "gas", "dissolved"]
+
+        dates = df["date"].unique()
+        dates.sort()
+
+        return {
+            "zones": zones if len(zones) > 1 else [],
+            "regions": regions if len(regions) > 1 else [],
+            "phases": phases,
+            "plume_groups": plume_groups if len(plume_groups) > 1 else [],
+            "dates": dates,
+        }
+
+    @staticmethod
+    def _validate(provider: EnsembleTableProvider) -> None:
+        col_names = provider.column_names()
+        required_columns = [
+            "date",
+            "amount",
+            "phase",
+            "containment",
+            "zone",
+            "region",
+            "plume_group",
+        ]
+        missing_columns = [col for col in required_columns if col not in col_names]
+        realization = provider.realizations()[0]
+        if len(missing_columns) == 0:
+            return
+        raise ContainmentDataValidationError(
+            f"EnsembleTableProvider validation error for provider {provider} in "
+            f"realization {realization} (and possibly other csv-files).\n"
+            f"  Expected columns: {', '.join(missing_columns)}\n"
+            f"  Found columns: {', '.join(col_names)}\n"
+            f"  (Missing columns: {', '.join(missing_columns)})"
+            f"Provided files are possibly from an outdated version of ccs-scripts?"
+        )

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/ensemble_well_picks.py

@@ -0,0 +1,105 @@
+import logging
+from functools import cached_property
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from webviz_subsurface._utils.webvizstore_functions import read_csv
+from webviz_subsurface.plugins._co2_leakage._utilities._misc import realization_paths
+from webviz_subsurface.plugins._map_viewer_fmu._tmp_well_pick_provider import (
+    WellPickProvider,
+)
+
+LOGGER = logging.getLogger(__name__)
+
+
+class EnsembleWellPicks:
+    def __init__(
+        self,
+        ens_path: str,
+        well_picks_path: str,
+        map_surface_names_to_well_pick_names: Optional[Dict[str, str]],
+    ):
+        self._absolute_well_pick_provider: Optional[WellPickProvider] = None
+        self._per_real_well_pick_providers: Dict[int, WellPickProvider] = {}
+
+        if Path(well_picks_path).is_absolute():
+            self._absolute_well_pick_provider = _try_get_well_pick_provider(
+                read_csv(well_picks_path),
+                map_surface_names_to_well_pick_names,
+            )
+        else:
+            realizations = realization_paths(ens_path)
+            for r, r_path in realizations.items():
+                try:
+                    self._per_real_well_pick_providers[r] = WellPickProvider(
+                        read_csv(r_path / well_picks_path),
+                        map_surface_names_to_well_pick_names,
+                    )
+                except (FileNotFoundError, OSError) as e:
+                    LOGGER.warning(
+                        f"Failed to find well picks for realization {r} at {r_path}: {e}"
+                    )
+
+    @cached_property
+    def well_names(self) -> List[str]:
+        if self._absolute_well_pick_provider is not None:
+            return self._absolute_well_pick_provider.well_names()
+
+        return list(
+            dict.fromkeys(
+                w
+                for v in self._per_real_well_pick_providers.values()
+                for w in v.well_names()
+            ).keys()
+        )
+
+    def geojson_layer(
+        self, realization: int, selected_wells: List[str], formation: str
+    ) -> Optional[Dict[str, Any]]:
+        if self._absolute_well_pick_provider is not None:
+            wpp = self._absolute_well_pick_provider
+        elif realization in self._per_real_well_pick_providers:
+            wpp = self._per_real_well_pick_providers[realization]
+        else:
+            return None
+
+        well_data = dict(wpp.get_geojson(selected_wells, formation))
+        if "features" in well_data:
+            if len(well_data["features"]) == 0:
+                wellstring = "well: " if len(selected_wells) == 1 else "wells: "
+                wellstring += ", ".join(selected_wells)
+                LOGGER.warning(
+                    f"Combination of formation: {formation} and "
+                    f"{wellstring} not found in well picks file."
+                )
+            for i in range(len(well_data["features"])):
+                current_attribute = well_data["features"][i]["properties"]["attribute"]
+                well_data["features"][i]["properties"]["attribute"] = (
+                    " " + current_attribute
+                )
+
+        return {
+            "@@type": "GeoJsonLayer",
+            "name": "Well Picks",
+            "id": "well-picks-layer",
+            "data": well_data,
+            "visible": True,
+            "getText": "@@=properties.attribute",
+            "getTextSize": 12,
+            "getTextAnchor": "start",
+            "pointType": "circle+text",
+            "lineWidthMinPixels": 2,
+            "pointRadiusMinPixels": 2,
+            "pickable": True,
+            "parameters": {"depthTest": False},
+        }
+
+
+def _try_get_well_pick_provider(
+    p: Path, name_mapping: Optional[Dict[str, str]]
+) -> Optional[WellPickProvider]:
+    try:
+        return WellPickProvider(read_csv(p), name_mapping)
+    except OSError as e:
+        LOGGER.warning(f"Failed to read well picks file '{p}': {e}")
+        return None

webviz_subsurface/plugins/_co2_leakage/_utilities/generic.py

@@ -1,22 +1,145 @@
+from __future__ import (  # Change to import Self from typing if we update to Python >3.11
+    annotations,
+)
+
+from typing import Dict, List, TypedDict
+
 from webviz_subsurface._utils.enum_shim import StrEnum
 
 
 class MapAttribute(StrEnum):
     MIGRATION_TIME_SGAS = "Migration time (SGAS)"
     MIGRATION_TIME_AMFG = "Migration time (AMFG)"
+    MIGRATION_TIME_XMF2 = "Migration time (XMF2)"
     MAX_SGAS = "Maximum SGAS"
     MAX_AMFG = "Maximum AMFG"
+    MAX_XMF2 = "Maximum XMF2"
+    MAX_SGSTRAND = "Maximum SGSTRAND"
+    MAX_SGTRH = "Maximum SGTRH"
     SGAS_PLUME = "Plume (SGAS)"
     AMFG_PLUME = "Plume (AMFG)"
+    XMF2_PLUME = "Plume (XMF2)"
+    SGSTRAND_PLUME = "Plume (SGSTRAND)"
+    SGTRH_PLUME = "Plume (SGTRH)"
     MASS = "Mass"
     DISSOLVED = "Dissolved mass"
-    FREE = "Free mass"
+    FREE = "Free gas mass"
+    FREE_GAS = "Free gas phase mass"
+    TRAPPED_GAS = "Trapped gas phase mass"
+
+
+class MapGroup(StrEnum):
+    MIGRATION_TIME_SGAS = "SGAS"
+    MIGRATION_TIME_AMFG = "AMFG"
+    MIGRATION_TIME_XMF2 = "XMF2"
+    MAX_SGAS = "SGAS"
+    MAX_AMFG = "AMFG"
+    MAX_XMF2 = "XMF2"
+    MAX_SGSTRAND = "SGSTRAND"
+    MAX_SGTRH = "SGTRH"
+    SGAS_PLUME = "SGAS"
+    AMFG_PLUME = "AMFG"
+    XMF2_PLUME = "XMF2"
+    SGSTRAND_PLUME = "SGSTRAND"
+    SGTRH_PLUME = "SGTRH"
+    MASS = "CO2 MASS"
+    DISSOLVED = "CO2 MASS"
+    FREE = "CO2 MASS"
+    FREE_GAS = "CO2 MASS"
+    TRAPPED_GAS = "CO2 MASS"
+
+
+map_group_labels = {
+    "SGAS": "Gas phase",
+    "AMFG": "Dissolved phase",
+    "XMF2": "Dissolved phase",
+    "SGSTRAND": "Trapped gas phase",
+    "SGTRH": "Trapped gas phase",
+    "CO2 MASS": "CO2 mass",
+}
+
+
+class MapType(StrEnum):
+    MIGRATION_TIME_SGAS = "MIGRATION_TIME"
+    MIGRATION_TIME_AMFG = "MIGRATION_TIME"
+    MIGRATION_TIME_XMF2 = "MIGRATION_TIME"
+    MAX_SGAS = "MAX"
+    MAX_AMFG = "MAX"
+    MAX_XMF2 = "MAX"
+    MAX_SGSTRAND = "MAX"
+    MAX_SGTRH = "MAX"
+    SGAS_PLUME = "PLUME"
+    AMFG_PLUME = "PLUME"
+    XMF2_PLUME = "PLUME"
+    SGSTRAND_PLUME = "PLUME"
+    SGTRH_PLUME = "PLUME"
+    MASS = "MASS"
+    DISSOLVED = "MASS"
+    FREE = "MASS"
+    FREE_GAS = "MASS"
+    TRAPPED_GAS = "MASS"
+
+
+class MapNamingConvention(StrEnum):
+    MIGRATION_TIME_SGAS = "migrationtime_sgas"
+    MIGRATION_TIME_AMFG = "migrationtime_amfg"
+    MIGRATION_TIME_XMF2 = "migrationtime_xmf2"
+    MAX_SGAS = "max_sgas"
+    MAX_AMFG = "max_amfg"
+    MAX_XMF2 = "max_xmf2"
+    MAX_SGSTRAND = "max_sgstrand"
+    MAX_SGTRH = "max_sgtrh"
+    MASS = "co2_mass_total"
+    DISSOLVED = "co2_mass_dissolved_phase"
+    FREE = "co2_mass_gas_phase"
+    FREE_GAS = "co2_mass_free_gas_phase"
+    TRAPPED_GAS = "co2_mass_trapped_gas_phase"
+
+
+class FilteredMapAttribute:
+    def __init__(self, mapping: Dict):
+        self.mapping = mapping
+        map_types = {
+            key: MapType[key].value
+            for key in MapAttribute.__members__
+            if MapAttribute[key].value in self.mapping
+        }
+        map_groups = {
+            key: MapGroup[key].value
+            for key in MapAttribute.__members__
+            if MapAttribute[key].value in self.mapping
+        }
+        map_attrs_with_plume = [
+            map_groups[key] for key, value in map_types.items() if value == "MAX"
+        ]
+        plume_request = {
+            f"Plume ({item})": f"{item.lower()}_plume" for item in map_attrs_with_plume
+        }
+        self.mapping.update(plume_request)
+        self.filtered_values = self.filter_map_attribute()
+
+    def filter_map_attribute(self) -> Dict:
+        return {
+            MapAttribute[key]: self.mapping[MapAttribute[key].value]
+            for key in MapAttribute.__members__
+            if MapAttribute[key].value in self.mapping
+        }
+
+    def __getitem__(self, key: MapAttribute) -> MapAttribute:
+        if isinstance(key, MapAttribute):
+            return self.filtered_values[key]
+        raise KeyError(f"Key must be a MapAttribute, " f"got {type(key)} instead.")
+
+    @property
+    def values(self) -> Dict:
+        return self.filtered_values
 
 
 class Co2MassScale(StrEnum):
     NORMALIZE = "Fraction"
+    KG = "kg"
+    TONS = "tons"
     MTONS = "M tons"
-    KG = "Kg"
 
 
 class Co2VolumeScale(StrEnum):
@@ -42,6 +165,8 @@ class LayoutLabels(StrEnum):
     COMMON_SELECTIONS = "Options and global filters"
     FEEDBACK = "User feedback"
     VISUALIZATION_UPDATE = "Update threshold"
+    VISUALIZATION_THRESHOLDS = "Manage visualization filter"
+    ALL_REAL = "Select all"
 
 
 # pylint: disable=too-few-public-methods
@@ -56,6 +181,13 @@ class LayoutStyle:
         "background-color": "lightgrey",
     }
 
+    ALL_REAL_BUTTON = {
+        "marginLeft": "10px",
+        "height": "25px",
+        "line-height": "25px",
+        "background-color": "lightgrey",
+    }
+
     FEEDBACK_BUTTON = {
         "marginBottom": "10px",
         "width": "100%",
@@ -70,3 +202,39 @@ class LayoutStyle:
         "line-height": "30px",
         "background-color": "lightgrey",
     }
+
+    THRESHOLDS_BUTTON = {
+        "marginTop": "10px",
+        "width": "100%",
+        "height": "30px",
+        "line-height": "30px",
+        "padding": "0",
+        "background-color": "lightgrey",
+    }
+
+
+class MenuOptions(TypedDict):
+    zones: List[str]
+    regions: List[str]
+    phases: List[str]
+    plume_groups: List[str]
+    dates: List[str]
+
+
+class MapThresholds:
+    def __init__(self, mapping: FilteredMapAttribute):
+        self.standard_thresholds = {
+            MapAttribute[key.name].value: 0.0
+            for key in mapping.filtered_values.keys()
+            if MapType[MapAttribute[key.name].name].value
+            not in ["PLUME", "MIGRATION_TIME"]
+        }
+        if MapAttribute.MAX_AMFG in self.standard_thresholds.keys():
+            self.standard_thresholds[MapAttribute.MAX_AMFG] = 0.0005
+
+
+class BoundarySettings(TypedDict):
+    polygon_file_pattern: str
+    attribute: str
+    hazardous_name: str
+    containment_name: str