webviz-subsurface 0.2.33__py3-none-any.whl → 0.2.35__py3-none-any.whl

webviz_subsurface/_models/parameter_model.py

@@ -151,6 +151,7 @@ class ParametersModel:
         # if mix of gen_kw and sensitivity ensembles add
         # dummy sensitivvity columns to gen_kw ensembles
         gen_kw_mask = self._dataframe["SENSNAME"].isnull()
+        self._dataframe["SENSNAME"] = self._dataframe["SENSNAME"].astype(str)
         self._dataframe.loc[gen_kw_mask, "SENSNAME"] = "🎲"
         self._dataframe.loc[gen_kw_mask, "SENSCASE"] = "p10_p90"
 

webviz_subsurface/_providers/ensemble_grid_provider/_xtgeo_to_vtk_explicit_structured_grid.py

@@ -75,7 +75,7 @@ def _create_vtk_esgrid_from_verts_and_conn(
     vtk_cell_array.SetData(8, conn_idarr)
 
     vtk_esgrid = vtkExplicitStructuredGrid()
-    vtk_esgrid.SetDimensions(point_dims.tolist())
+    vtk_esgrid.SetDimensions(point_dims.tolist())  # type: ignore
     vtk_esgrid.SetPoints(vtk_points)
     vtk_esgrid.SetCells(vtk_cell_array)
 

webviz_subsurface/_providers/ensemble_grid_provider/grid_viz_service.py

@@ -365,15 +365,15 @@ class GridVizService:
 
             plane = vtkPlane()
             plane.SetOrigin([x_0, y_0, 0])
-            plane.SetNormal(right_vec.tolist())
+            plane.SetNormal(right_vec.tolist())  # type: ignore
 
             plane_0 = vtkPlane()
             plane_0.SetOrigin([x_0, y_0, 0])
-            plane_0.SetNormal(fwd_vec.tolist())
+            plane_0.SetNormal(fwd_vec.tolist())  # type: ignore
 
             plane_1 = vtkPlane()
             plane_1.SetOrigin([x_1, y_1, 0])
-            plane_1.SetNormal((-fwd_vec).tolist())
+            plane_1.SetNormal((-fwd_vec).tolist())  # type: ignore
 
             cutter_alg.SetPlane(plane)
             cutter_alg.Update()
@@ -478,7 +478,9 @@ class GridVizService:
         i_ref = reference(0)
         j_ref = reference(0)
         k_ref = reference(0)
-        grid.ComputeCellStructuredCoords(cell_id, i_ref, j_ref, k_ref, True)  # type: ignore[arg-type]
+        grid.ComputeCellStructuredCoords(
+            cell_id, i_ref, j_ref, k_ref, True  # type: ignore[arg-type]
+        )
 
         cell_property_val: Optional[np.ndarray] = None
         if property_spec:

webviz_subsurface/_providers/ensemble_summary_provider/_provider_impl_arrow_lazy.py

@@ -313,7 +313,7 @@ class ProviderImplArrowLazy(EnsembleSummaryProvider):
             f"find_unique={et_find_unique_ms}ms)"
         )
 
-        return intersected_dates.astype(datetime.datetime).tolist()
+        return intersected_dates.astype(datetime.datetime).tolist()  # type: ignore
 
     def get_vectors_df(
         self,
@@ -377,7 +377,7 @@ class ProviderImplArrowLazy(EnsembleSummaryProvider):
             table = table.filter(real_mask)
         et_filter_ms = timer.lap_ms()
 
-        np_lookup_date = np.datetime64(date, "ms")
+        np_lookup_date = np.datetime64(date).astype("M8[ms]")
         table = sample_segmented_multi_real_table_at_date(table, np_lookup_date)
 
         et_resample_ms = timer.lap_ms()

webviz_subsurface/_providers/ensemble_summary_provider/_provider_impl_arrow_presampled.py

@@ -374,7 +374,7 @@ class ProviderImplArrowPresampled(EnsembleSummaryProvider):
             f"find_unique={et_find_unique_ms}ms)"
         )
 
-        return intersected_dates.astype(datetime.datetime).tolist()
+        return intersected_dates.astype(datetime.datetime).tolist()  # type: ignore
 
     def get_vectors_df(
         self,

webviz_subsurface/_providers/ensemble_summary_provider/_resampling.py

@@ -17,7 +17,7 @@ def _truncate_day_to_monday(datetime_day: np.datetime64) -> np.datetime64:
 def _quarter_start_month(datetime_day: np.datetime64) -> np.datetime64:
     # A bit hackish, utilizes the fact that datetime64 is relative to epoch
     # 1970-01-01 which is the first day in Q1.
-    datetime_month = np.datetime64(datetime_day, "M")
+    datetime_month = datetime_day.astype("M8[M]")
     return datetime_month - (datetime_month.astype(int) % 3)
 
 
@@ -30,44 +30,52 @@ def generate_normalized_sample_dates(
     """
 
     if freq == Frequency.DAILY:
-        start = np.datetime64(min_date, "D")
-        stop = np.datetime64(max_date, "D")
+        start = min_date.astype("M8[D]")
+        stop = max_date.astype("M8[D]")
         if stop < max_date:
-            stop += 1
-        sampledates = np.arange(start, stop + 1)
+            stop += np.timedelta64(1, "D")
+        sampledates = np.arange(start, stop + np.timedelta64(1, "D"))
+
     elif freq == Frequency.WEEKLY:
-        start = _truncate_day_to_monday(np.datetime64(min_date, "D"))
-        stop = _truncate_day_to_monday(np.datetime64(max_date, "D"))
+        start = _truncate_day_to_monday(min_date.astype("M8[D]"))
+        stop = _truncate_day_to_monday(max_date.astype("M8[D]"))
         if start > min_date:
-            start -= 7
+            start -= np.timedelta64(7, "D")
         if stop < max_date:
-            stop += 7
-        sampledates = np.arange(start, stop + 1, 7)
+            stop += np.timedelta64(7, "D")
+        sampledates = np.arange(
+            start, stop + np.timedelta64(1, "D"), np.timedelta64(7, "D")
+        )
+
     elif freq == Frequency.MONTHLY:
-        start = np.datetime64(min_date, "M")
-        stop = np.datetime64(max_date, "M")
+        start = min_date.astype("M8[M]")
+        stop = max_date.astype("M8[M]")
         if stop < max_date:
-            stop += 1
-        sampledates = np.arange(start, stop + 1)
+            stop += np.timedelta64(1, "M")
+        sampledates = np.arange(start, stop + np.timedelta64(1, "M"))
+
     elif freq == Frequency.QUARTERLY:
         start = _quarter_start_month(min_date)
         stop = _quarter_start_month(max_date)
         if stop < max_date:
-            stop += 3
-        sampledates = np.arange(start, stop + 1, 3)
+            stop += np.timedelta64(3, "M")
+        sampledates = np.arange(
+            start, stop + np.timedelta64(1, "M"), np.timedelta64(3, "M")
+        )
+
     elif freq == Frequency.YEARLY:
-        start = np.datetime64(min_date, "Y")
-        stop = np.datetime64(max_date, "Y")
+        start = min_date.astype("M8[Y]")
+        stop = max_date.astype("M8[Y]")
         if stop < max_date:
-            stop += 1
-        sampledates = np.arange(start, stop + 1)
+            stop += np.timedelta64(1, "Y")
+        sampledates = np.arange(start, stop + np.timedelta64(1, "Y"))
+
     else:
         raise NotImplementedError(
             f"Currently not supporting resampling to frequency {freq}."
         )
 
-    sampledates = sampledates.astype("datetime64[ms]")
-
+    sampledates = sampledates.astype("M8[ms]")
     return sampledates
 
 

webviz_subsurface/_providers/ensemble_surface_provider/_provider_impl_file.py

@@ -11,7 +11,6 @@ import xtgeo
 from webviz_subsurface._utils.enum_shim import StrEnum
 from webviz_subsurface._utils.perf_timer import PerfTimer
 
-from ._stat_surf_cache import StatSurfCache
 from ._surface_discovery import SurfaceFileInfo
 from .ensemble_surface_provider import (
     EnsembleSurfaceProvider,
@@ -26,7 +25,6 @@ LOGGER = logging.getLogger(__name__)
 
 REL_SIM_DIR = "sim"
 REL_OBS_DIR = "obs"
-REL_STAT_CACHE_DIR = "stat_cache"
 
 
 # pylint: disable=too-few-public-methods
@@ -53,8 +51,6 @@ class ProviderImplFile(EnsembleSurfaceProvider):
         self._provider_dir = provider_dir
         self._inventory_df = surface_inventory_df
 
-        self._stat_surf_cache = StatSurfCache(self._provider_dir / REL_STAT_CACHE_DIR)
-
     @staticmethod
     # pylint: disable=too-many-locals
     def write_backing_store(
@@ -237,22 +233,10 @@ class ProviderImplFile(EnsembleSurfaceProvider):
     ) -> Optional[xtgeo.RegularSurface]:
         timer = PerfTimer()
 
-        surf = self._stat_surf_cache.fetch(address)
-        if surf:
-            LOGGER.debug(
-                f"Fetched statistical surface from cache in: {timer.elapsed_s():.2f}s"
-            )
-            return surf
-
         surf = self._create_statistical_surface(address)
-        et_create_s = timer.lap_s()
-
-        self._stat_surf_cache.store(address, surf)
-        et_write_cache_s = timer.lap_s()
 
         LOGGER.debug(
-            f"Created and wrote statistical surface to cache in: {timer.elapsed_s():.2f}s ("
-            f"create={et_create_s:.2f}s, store={et_write_cache_s:.2f}s), "
+            f"Created statistical surface in: {timer.elapsed_s():.2f}s ("
             f"[stat={address.statistic}, "
             f"attr={address.attribute}, name={address.name}, date={address.datestr}]"
         )

webviz_subsurface/_providers/ensemble_surface_provider/_surface_to_float32_array.py

@@ -6,7 +6,7 @@ import xtgeo
 
 def surface_to_float32_array(surface: xtgeo.RegularSurface) -> io.BytesIO:
     values = surface.values.astype(np.float32)
-    values.fill_value = np.NaN
+    values.fill_value = np.nan
     values = np.ma.filled(values)
 
     # Rotate 90 deg left.

webviz_subsurface/_utils/parameter_response.py

@@ -37,7 +37,9 @@ def filter_and_sum_responses(
     if aggregation == "sum":
         return df.groupby("REAL").sum().reset_index()[["REAL", response]]
     if aggregation == "mean":
-        return df.groupby("REAL").mean().reset_index()[["REAL", response]]
+        return (
+            df.groupby("REAL").mean(numeric_only=True).reset_index()[["REAL", response]]
+        )
     raise ValueError(f"Unknown aggregation '{aggregation}'.")
 
 

webviz_subsurface/plugins/_bhp_qc/views/_view_functions.py

@@ -20,7 +20,7 @@ def filter_df(df: pd.DataFrame, ensemble: str, wells: List[str]) -> pd.DataFrame
     in statistics.
     """
     columns = ["ENSEMBLE"] + [f"WBHP:{well}" for well in wells]
-    return df.loc[df["ENSEMBLE"] == ensemble][columns].replace(0, np.NaN)
+    return df.loc[df["ENSEMBLE"] == ensemble][columns].replace(0, np.nan)
 
 
 def calc_statistics(df: pd.DataFrame) -> pd.DataFrame:

webviz_subsurface/plugins/_co2_leakage/_utilities/plume_extent.py

@@ -105,4 +105,4 @@ def _find_contours(
 
 def _simplify(poly: np.ndarray, simplify_dist: float) -> List[List[float]]:
     simplified = shapely.geometry.LineString(poly).simplify(simplify_dist)
-    return np.array(simplified.coords).tolist()
+    return np.array(simplified.coords).tolist()  # type: ignore

webviz_subsurface/plugins/_co2_leakage/views/mainview/mainview.py

@@ -6,7 +6,7 @@ from dash import 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 DashSubsurfaceViewer
+from webviz_subsurface_components import SubsurfaceViewer
 
 
 class MainView(ViewABC):
@@ -48,7 +48,7 @@ class MapViewElement(ViewElementABC):
                     children=[
                         html.Div(
                             [
-                                DashSubsurfaceViewer(
+                                SubsurfaceViewer(
                                     id=self.register_component_unique_id(
                                         self.Ids.DECKGL_MAP
                                     ),

webviz_subsurface/plugins/_grid_viewer_fmu/views/view_3d/view_elements/_vtk_view_3d_element.py

@@ -2,7 +2,7 @@ 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 ViewElementABC
-from webviz_subsurface_components import DashSubsurfaceViewer
+from webviz_subsurface_components import SubsurfaceViewer
 
 
 class VTKView3D(ViewElementABC):
@@ -45,7 +45,7 @@ class VTKView3D(ViewElementABC):
                 html.Div(
                     style={"position": "absolute", "width": "100%", "height": "90%"},
                     children=[
-                        DashSubsurfaceViewer(
+                        SubsurfaceViewer(
                             id=self.register_component_unique_id(VTKView3D.Ids.VIEW),
                             layers=[
                                 {

webviz_subsurface/plugins/_history_match.py

@@ -155,7 +155,7 @@ def _get_sorted_edges(number_observation_groups: int) -> Dict[str, list]:
             np.random.chisquare(df=1, size=number_observation_groups)
         )
 
-    sorted_values = np.flip(sorted_values, 0)
+    sorted_values = np.flip(sorted_values, 0)  # type: ignore
 
     p10 = np.percentile(sorted_values, 90, axis=1)
     p90 = np.percentile(sorted_values, 10, axis=1)

webviz_subsurface/plugins/_map_viewer_fmu/_tmp_well_pick_provider.py

@@ -3,6 +3,7 @@ from typing import Dict, List, Optional
 import geojson
 import pandas as pd
 
+from webviz_subsurface._utils.colors import hex_to_rgb
 from webviz_subsurface._utils.enum_shim import StrEnum
 
 
@@ -64,10 +65,11 @@ class WellPickProvider:
             point = geojson.Point(coordinates=coords, validate=validate_geometry)
 
             geocoll = geojson.GeometryCollection(geometries=[point])
-
             properties = {
                 "name": row[WellPickTableColumns.WELL],
                 "attribute": str(row[attribute]),
+                "point_color": hex_to_rgb(row.get("point_color", "#000")),
+                "text_color": hex_to_rgb(row.get("text_color", "#000")),
             }
 
             feature = geojson.Feature(

webviz_subsurface/plugins/_map_viewer_fmu/_types.py

@@ -9,6 +9,7 @@ class LayerTypes(StrEnum):
     WELLTOPSLAYER = "GeoJsonLayer"
     DRAWING = "DrawingLayer"
     FAULTPOLYGONS = "FaultPolygonsLayer"
+    FIELD_OUTLINE = "GeoJsonLayer"
     GEOJSON = "GeoJsonLayer"
 
 

webviz_subsurface/plugins/_map_viewer_fmu/_utils.py

@@ -1,8 +1,10 @@
 import base64
 import io
 import math
-from typing import List
+from typing import Dict, List
 
+import geojson
+import xtgeo
 from PIL import Image, ImageDraw
 
 
@@ -39,3 +41,18 @@ def create_colormap_image_string(
         draw.rectangle([(x_0, 0), (x_1, height)], fill=rgb_to_hex(color))
 
     return f"data:image/png;base64,{image_to_base64(img)}"
+
+
+def xtgeo_polygons_to_geojson(polygons: xtgeo.Polygons) -> Dict:
+    feature_arr = []
+    for name, polygon in polygons.dataframe.groupby("POLY_ID"):
+        coords = [list(zip(polygon.X_UTME, polygon.Y_UTMN))]
+        feature = geojson.Feature(
+            geometry=geojson.Polygon(coords),
+            properties={
+                "name": f"id:{name}",
+                "color": [200, 200, 200],
+            },
+        )
+        feature_arr.append(feature)
+    return geojson.FeatureCollection(features=feature_arr)

webviz_subsurface/plugins/_map_viewer_fmu/callbacks.py

@@ -9,6 +9,7 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import webviz_subsurface_components as wsc
+import xtgeo
 from dash import ALL, MATCH, Input, Output, State, callback, callback_context, no_update
 from dash.exceptions import PreventUpdate
 from webviz_config import EncodedFile
@@ -32,7 +33,7 @@ from webviz_subsurface._providers import (
 from ._layer_model import DeckGLMapLayersModel
 from ._tmp_well_pick_provider import WellPickProvider
 from ._types import LayerTypes, SurfaceMode
-from ._utils import round_to_significant
+from ._utils import round_to_significant, xtgeo_polygons_to_geojson
 from .layout import (
     DefaultSettings,
     LayoutElements,
@@ -51,6 +52,8 @@ def plugin_callbacks(
     surface_server: Union[SurfaceArrayServer, SurfaceImageServer],
     ensemble_fault_polygons_providers: Dict[str, EnsembleFaultPolygonsProvider],
     fault_polygons_server: FaultPolygonsServer,
+    field_outline_polygons: xtgeo.Polygons,
+    field_outline_color: Tuple[float, float, float],
     map_surface_names_to_fault_polygons: Dict[str, str],
     well_picks_provider: Optional[WellPickProvider],
     fault_polygon_attribute: Optional[str],
@@ -518,9 +521,27 @@ def plugin_callbacks(
                     layer_data={
                         "data": well_picks_provider.get_geojson(
                             selected_wells, horizon_name
-                        )
+                        ),
+                        "getLineColor": "@@=properties.point_color",
+                        "getFillColor": "@@=properties.point_color",
+                        "getTextColor": "@@=properties.text_color",
+                    },
+                )
+            if (
+                LayoutLabels.SHOW_FIELD_OUTLINE in options
+                and field_outline_polygons is not None
+            ):
+                layer_model.update_layer_by_id(
+                    layer_id=f"{LayoutElements.FIELD_OUTLINE_LAYER}-{idx}",
+                    layer_data={
+                        "data": xtgeo_polygons_to_geojson(field_outline_polygons),
+                        "filled": False,
+                        "depthTest": False,
+                        "lineWidthMinPixels": 2,
+                        "getLineColor": field_outline_color,
                     },
                 )
+
         viewports = []
         view_annotations = []
         for idx, data in enumerate(surface_elements):
@@ -550,10 +571,13 @@ def plugin_callbacks(
                     "show3D": False,
                     "isSync": True,
                     "layerIds": [
-                        f"{LayoutElements.MAP3D_LAYER}-{idx}"
-                        if isinstance(surface_server, SurfaceArrayServer)
-                        else f"{LayoutElements.COLORMAP_LAYER}-{idx}",
+                        (
+                            f"{LayoutElements.MAP3D_LAYER}-{idx}"
+                            if isinstance(surface_server, SurfaceArrayServer)
+                            else f"{LayoutElements.COLORMAP_LAYER}-{idx}"
+                        ),
                         f"{LayoutElements.FAULTPOLYGONS_LAYER}-{idx}",
+                        f"{LayoutElements.FIELD_OUTLINE_LAYER}-{idx}",
                         f"{LayoutElements.WELLS_LAYER}-{idx}",
                     ],
                     "name": make_viewport_label(data, tab_name, multi),
@@ -851,13 +875,15 @@ def plugin_callbacks(
                     "colormap": {"value": colormap, "options": colormaps},
                     "color_range": {
                         "value": color_range,
-                        "step": calculate_slider_step(
-                            min_value=value_range[0],
-                            max_value=value_range[1],
-                            steps=100,
-                        )
-                        if value_range[0] != value_range[1]
-                        else 0,
+                        "step": (
+                            calculate_slider_step(
+                                min_value=value_range[0],
+                                max_value=value_range[1],
+                                steps=100,
+                            )
+                            if value_range[0] != value_range[1]
+                            else 0
+                        ),
                         "range": value_range,
                     },
                 }

webviz_subsurface/plugins/_map_viewer_fmu/layout.py

@@ -3,7 +3,7 @@ from typing import Any, Callable, Dict, List, Union
 
 import webviz_core_components as wcc
 from dash import dcc, html
-from webviz_subsurface_components import DashSubsurfaceViewer  # type: ignore
+from webviz_subsurface_components import SubsurfaceViewer  # type: ignore
 
 from webviz_subsurface._utils.enum_shim import StrEnum
 
@@ -37,15 +37,17 @@ class LayoutElements(StrEnum):
     RANGE_RESET = "color-range-reset-button"
     RESET_BUTTOM_CLICK = "color-range-reset-stored-state"
     FAULTPOLYGONS = "fault-polygon-toggle"
+    FIELD_OUTLINE_TOGGLE = "field-outline-toggle"
     WRAPPER = "wrapper-for-selector-component"
     COLORWRAPPER = "wrapper-for-color-selector-component"
     OPTIONS = "options"
 
     COLORMAP_LAYER = "deckglcolormaplayer"
-    HILLSHADING_LAYER = "deckglhillshadinglayer"
+
     WELLS_LAYER = "deckglwelllayer"
     MAP3D_LAYER = "deckglmap3dlayer"
     FAULTPOLYGONS_LAYER = "deckglfaultpolygonslayer"
+    FIELD_OUTLINE_LAYER = "deckglfieldoutlinelayer"
     REALIZATIONS_FILTER = "realization-filter-selector"
     OPTIONS_DIALOG = "options-dialog"
 
@@ -69,8 +71,8 @@ class LayoutLabels(StrEnum):
     LINK = "🔗 Link"
     FAULTPOLYGONS = "Fault polygons"
     SHOW_FAULTPOLYGONS = "Show fault polygons"
+    SHOW_FIELD_OUTLINE = "Show field outline"
     SHOW_WELLS = "Show wells"
-    SHOW_HILLSHADING = "Hillshading"
     COMMON_SELECTIONS = "Options and global filters"
     REAL_FILTER = "Realization filter"
     WELL_FILTER = "Well filter"
@@ -183,7 +185,7 @@ def main_layout(
     realizations: List[int],
     color_tables: List[Dict],
     show_fault_polygons: bool = True,
-    hillshading_enabled: bool = True,
+    show_field_outline: bool = False,
     render_surfaces_as_images: bool = True,
 ) -> html.Div:
     return html.Div(
@@ -240,9 +242,9 @@ def main_layout(
             DialogLayout(
                 get_uuid,
                 show_fault_polygons,
+                show_field_outline,
                 well_names,
                 realizations,
-                hillshading_enabled,
             ),
         ]
     )
@@ -269,7 +271,7 @@ class MapViewLayout(FullScreen):
     ) -> None:
         super().__init__(
             children=html.Div(
-                DashSubsurfaceViewer(
+                SubsurfaceViewer(
                     id={"id": get_uuid(LayoutElements.DECKGLMAP), "tab": tab},
                     layers=update_map_layers(1, render_surfaces_as_images),
                     colorTables=color_tables,
@@ -304,18 +306,20 @@ class DialogLayout(wcc.Dialog):
         self,
         get_uuid: Callable,
         show_fault_polygons: bool,
+        show_field_outline: bool,
         well_names: List[str],
         realizations: List[int],
-        hillshading_enabled: bool = True,
     ) -> None:
-        checklist_options = [LayoutLabels.SHOW_HILLSHADING]
-        checklist_values = (
-            [LayoutLabels.SHOW_HILLSHADING] if hillshading_enabled else []
-        )
+        checklist_options = []
+        checklist_values = []
         if show_fault_polygons:
             checklist_options.append(LayoutLabels.SHOW_FAULTPOLYGONS)
             checklist_values.append(LayoutLabels.SHOW_FAULTPOLYGONS)
 
+        if show_field_outline:
+            checklist_options.append(LayoutLabels.SHOW_FIELD_OUTLINE)
+            checklist_values.append(LayoutLabels.SHOW_FIELD_OUTLINE)
+
         if well_names:
             checklist_options.append(LayoutLabels.SHOW_WELLS)
             checklist_values.append(LayoutLabels.SHOW_FAULTPOLYGONS)
@@ -358,9 +362,11 @@ class LinkCheckBox(wcc.Checklist):
         clicked = selector in DefaultSettings.LINKED_SELECTORS.get(tab, [])
         super().__init__(
             id={
-                "id": get_uuid(LayoutElements.LINK)
-                if selector not in ["color_range", "colormap"]
-                else get_uuid(LayoutElements.COLORLINK),
+                "id": (
+                    get_uuid(LayoutElements.LINK)
+                    if selector not in ["color_range", "colormap"]
+                    else get_uuid(LayoutElements.COLORLINK)
+                ),
                 "tab": tab,
                 "selector": selector,
             },
@@ -570,9 +576,11 @@ class MapSelectorLayout(html.Div):
     ) -> None:
         super().__init__(
             style={
-                "display": "none"
-                if tab == Tabs.STATS and selector == MapSelector.MODE
-                else "block"
+                "display": (
+                    "none"
+                    if tab == Tabs.STATS and selector == MapSelector.MODE
+                    else "block"
+                )
             },
             children=wcc.Selectors(
                 label=label,
@@ -805,7 +813,13 @@ def update_map_layers(
                     "parameters": {"depthTest": False},
                 }
             )
-
+        layers.append(
+            {
+                "@@type": LayerTypes.FIELD_OUTLINE,
+                "id": f"{LayoutElements.FIELD_OUTLINE_LAYER}-{idx}",
+                "data": {"type": "FeatureCollection", "features": []},
+            }
+        )
         if include_well_layer:
             layers.append(
                 {