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

webviz_subsurface/_components/tornado/_tornado_bar_chart.py

@@ -5,7 +5,7 @@ import plotly.graph_objects as go
 
 from webviz_subsurface._abbreviations.number_formatting import si_prefixed
 
-from ._tornado_data import TornadoData
+from ._tornado_data import SensitivityType, TornadoData
 
 
 class TornadoBarChart:
@@ -136,9 +136,25 @@ class TornadoBarChart:
             hovertext.append(text)
         return hovertext
 
+    def get_sensitivity_colors(self, case: str) -> List:
+        """Create color list for bars based on sensitivity type
+        If colors are set by sensitivity, just create a color per sensitivty.
+        If not handle scalar and mc sensitivities separately.
+        For scalar, that is sensitivities with two "cases", use separate colors for each case.
+        For mc, use one color.
+        """
+        if self._color_by_sens:
+            return self.create_color_list(self._tornadotable["sensname"])
+        colors = []
+        for _, row in self._tornadotable.iterrows():
+            if row["senstype"] == SensitivityType.MONTE_CARLO or case == "low":
+                colors.append(self._plotly_theme["layout"]["colorway"][0])
+            else:
+                colors.append(self._plotly_theme["layout"]["colorway"][1])
+        return colors
+
     @property
     def data(self) -> List:
-        colors = self.create_color_list(self._tornadotable["sensname"].unique())
         return [
             {
                 "type": "bar",
@@ -157,7 +173,7 @@ class TornadoBarChart:
                 "orientation": "h",
                 "marker": {
                     "line": {"width": 1.5, "color": "black"},
-                    "color": colors if self._color_by_sens else None,
+                    "color": self.get_sensitivity_colors("low"),
                 },
             },
             {
@@ -177,7 +193,7 @@ class TornadoBarChart:
                 "orientation": "h",
                 "marker": {
                     "line": {"width": 1.5, "color": "black"},
-                    "color": colors if self._color_by_sens else None,
+                    "color": self.get_sensitivity_colors("high"),
                 },
             },
         ]
@@ -193,6 +209,15 @@ class TornadoBarChart:
 
     @property
     def scatter_data(self) -> List[Dict]:
+        def get_color(case_name_arr: pd.Series, case_type_arr: pd.Series) -> List:
+            colors = []
+            for case_name, case_type in zip(case_name_arr, case_type_arr):
+                if case_name == "low" or case_type == SensitivityType.MONTE_CARLO:
+                    colors.append(self._plotly_theme["layout"]["colorway"][0])
+                else:
+                    colors.append(self._plotly_theme["layout"]["colorway"][1])
+            return colors
+
         return [
             {
                 "type": "scatter",
@@ -202,14 +227,9 @@ class TornadoBarChart:
                 "text": df["REAL"],
                 "hovertemplate": "REAL: <b>%{text}</b><br>"
                 + "X: <b>%{x:.1f}</b> <extra></extra>",
-                "marker": {
-                    "size": 15,
-                    "color": self._plotly_theme["layout"]["colorway"][0]
-                    if case == "low"
-                    else self._plotly_theme["layout"]["colorway"][1],
-                },
+                "marker": {"size": 15, "color": get_color(df["case"], df["casetype"])},
             }
-            for case, df in self._realtable.groupby("case")
+            for _, df in self._realtable.groupby("case")
         ]
 
     @property

webviz_subsurface/_components/tornado/_tornado_data.py

@@ -3,6 +3,15 @@ from typing import Dict, List, Optional, Union
 import numpy as np
 import pandas as pd
 
+from webviz_subsurface._utils.enum_shim import StrEnum
+
+
+class SensitivityType(StrEnum):
+    """Sensitivity types used in Tornado analysis."""
+
+    SCALAR = "scalar"
+    MONTE_CARLO = "mc"
+
 
 class TornadoData:
     REQUIRED_COLUMNS = ["REAL", "SENSNAME", "SENSCASE", "SENSTYPE", "VALUE"]
@@ -50,7 +59,11 @@ class TornadoData:
     def _create_real_df(self, dframe: pd.DataFrame) -> pd.DataFrame:
         """Make dataframe with value and case info per realization"""
         realdf = dframe[self.REQUIRED_COLUMNS].rename(
-            columns={"SENSNAME": "sensname", "SENSCASE": "senscase"}
+            columns={
+                "SENSNAME": "sensname",
+                "SENSCASE": "senscase",
+                "SENSTYPE": "senstype",
+            }
         )
 
         sensitivities = self._tornadotable["sensname"].unique()
@@ -61,7 +74,7 @@ class TornadoData:
                 casemask = realdf["REAL"].isin(val[f"real_{case}"])
                 realdf.loc[casemask, "case"] = case
 
-        mc_mask = realdf["SENSTYPE"] == "mc"
+        mc_mask = realdf["senstype"] == "mc"
         realdf["casetype"] = np.where(mc_mask, "mc", realdf["case"])
         realdf["sensname_case"] = np.where(
             mc_mask,
@@ -127,6 +140,7 @@ class TornadoData:
                                 sens_case_df["VALUE"].mean()
                             ),
                             "reals": list(map(int, sens_case_df["REAL"])),
+                            "senstype": SensitivityType.SCALAR,
                         }
                     )
             # If `SENSTYPE` is monte carlo get p10, p90
@@ -162,6 +176,7 @@ class TornadoData:
                         "values": p90,
                         "values_ref": self._scale_to_ref(p90),
                         "reals": low_reals,
+                        "senstype": SensitivityType.MONTE_CARLO,
                     }
                 )
                 avg_per_sensitivity.append(
@@ -171,6 +186,7 @@ class TornadoData:
                         "values": p10,
                         "values_ref": self._scale_to_ref(p10),
                         "reals": high_reals,
+                        "senstype": SensitivityType.MONTE_CARLO,
                     }
                 )
 
@@ -198,6 +214,7 @@ class TornadoData:
                     high["reals"] = []
                     high["senscase"] = None
                     high["values"] = self.reference_average
+
                 else:
                     low = (
                         low.copy()
@@ -218,6 +235,7 @@ class TornadoData:
                     "true_low": low["values"],
                     "low_reals": low["reals"],
                     "sensname": sensname,
+                    "senstype": sens_name_df["senstype"].unique()[0],
                     "high": self.calc_high_x(low["values_ref"], high["values_ref"]),
                     "high_base": self.calc_high_base(
                         low["values_ref"], high["values_ref"]

webviz_subsurface/_figures/timeseries_figure.py

@@ -211,7 +211,7 @@ class TimeSeriesFigure:
             .groupby(["DATE"])
             .agg(
                 [
-                    ("Mean", np.nanmean),
+                    ("Mean", "mean"),
                     ("P10", lambda x: np.nanpercentile(x, q=90)),
                     ("P90", lambda x: np.nanpercentile(x, q=10)),
                 ]

webviz_subsurface/_providers/ensemble_summary_provider/_provider_impl_arrow_lazy.py

@@ -160,7 +160,9 @@ class ProviderImplArrowLazy(EnsembleSummaryProvider):
             f"{len(unique_column_names)} unique column names"
         )
 
-        full_table = pa.concat_tables(per_real_tables.values(), promote=True)
+        full_table = pa.concat_tables(
+            per_real_tables.values(), promote_options="default"
+        )
         elapsed.concat_tables_s = timer.lap_s()
 
         real_arr = np.empty(full_table.num_rows, np.int32)

webviz_subsurface/_providers/ensemble_summary_provider/_provider_impl_arrow_presampled.py

@@ -214,7 +214,9 @@ class ProviderImplArrowPresampled(EnsembleSummaryProvider):
         )
 
         timer.lap_s()
-        full_table = pa.concat_tables(per_real_tables.values(), promote=True)
+        full_table = pa.concat_tables(
+            per_real_tables.values(), promote_options="default"
+        )
         elapsed.concat_tables_s = timer.lap_s()
 
         real_arr = np.empty(full_table.num_rows, np.int32)

webviz_subsurface/_providers/ensemble_table_provider/ensemble_table_provider_factory.py

@@ -10,6 +10,9 @@ from webviz_config.webviz_factory import WebvizFactory
 from webviz_config.webviz_factory_registry import WEBVIZ_FACTORY_REGISTRY
 from webviz_config.webviz_instance_info import WebvizRunMode
 
+from webviz_subsurface._utils.design_matrix import (
+    rename_design_matrix_parameter_columns,
+)
 from webviz_subsurface._utils.perf_timer import PerfTimer
 
 from ..ensemble_summary_provider._arrow_unsmry_import import (
@@ -283,6 +286,7 @@ class EnsembleTableProviderFactory(WebvizFactory):
             raise ValueError(
                 f"Failed to load 'parameter.txt' files for ensemble {ens_path}."
             )
+        ensemble_df = rename_design_matrix_parameter_columns(ensemble_df)
 
         elapsed_load_parameters_s = timer.lap_s()
 

webviz_subsurface/_providers/ensemble_table_provider/ensemble_table_provider_impl_arrow.py

@@ -101,7 +101,9 @@ class EnsembleTableProviderImplArrow(EnsembleTableProvider):
             f"{len(unique_column_names)} unique column names"
         )
 
-        full_table = pa.concat_tables(per_real_tables.values(), promote=True)
+        full_table = pa.concat_tables(
+            per_real_tables.values(), promote_options="default"
+        )
         elapsed.concat_tables_s = timer.lap_s()
 
         real_arr = np.empty(full_table.num_rows, np.int32)

webviz_subsurface/_utils/dataframe_utils.py

@@ -82,7 +82,7 @@ def make_date_column_datetime_object(df: pd.DataFrame) -> None:
     # pylint: disable = unidiomatic-typecheck
     if type(sampled_date_value) == pd.Timestamp:
         df["DATE"] = pd.Series(
-            df["DATE"].dt.to_pydatetime(), dtype=object, index=df.index
+            np.array(df["DATE"].dt.to_pydatetime()), dtype=object, index=df.index
         )
         return None
 

webviz_subsurface/_utils/design_matrix.py

@@ -0,0 +1,36 @@
+import logging
+
+import pandas as pd
+
+LOGGER = logging.getLogger(__name__)
+
+
+def rename_design_matrix_parameter_columns(parameter_df: pd.DataFrame) -> pd.DataFrame:
+    """Given a dataframe of parameters, checks if the DESIGN_MATRIX prefix is present.
+    If present assume this is a design matrix run. Return the dataframe with the prefix
+    removed. Also do a check if removing the prefix result in any duplicates.
+    If duplicates remove those and give a warning.
+    """
+
+    if any(col.startswith("DESIGN_MATRIX:") for col in parameter_df.columns):
+        original_columns = parameter_df.columns
+        stripped_columns = original_columns.str.replace(
+            r"^DESIGN_MATRIX:", "", regex=True
+        )
+        rename_map = {
+            old: new
+            for old, new in zip(original_columns, stripped_columns)
+            if old != new
+        }
+        conflict_names = set(rename_map.values()) & set(original_columns)
+        if conflict_names:
+            LOGGER.info(
+                "DESIGN_MATRIX run detected, but non design matrix parameters was found."
+            )
+            LOGGER.info(
+                f"The following parameters will be dropped: {sorted(conflict_names)}"
+            )
+        parameter_df = parameter_df.drop(columns=conflict_names)
+
+        parameter_df = parameter_df.rename(columns=rename_map)
+    return parameter_df

webviz_subsurface/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.2.40'
+__version_tuple__ = version_tuple = (0, 2, 40)
+
+__commit_id__ = commit_id = None

webviz_subsurface/plugins/_bhp_qc/views/_view_functions.py

@@ -41,15 +41,15 @@ def calc_statistics(df: pd.DataFrame) -> pd.DataFrame:
     # Calculate statistics, ignoring NaNs.
     stat_df = (
         df.groupby("ENSEMBLE")
-        .agg([np.nanmean, "count", np.nanstd, np.nanmin, np.nanmax, p10, p50, p90])
+        .agg(["mean", "count", "std", "min", "max", p10, p50, p90])
         .reset_index(drop=True, level="ENSEMBLE")
     )
     # Rename nanmin, nanmax and nanmean to min, max and mean.
     col_stat_label_map = {
-        "nanmin": "min",
-        "nanmax": "max",
-        "nanmean": "mean",
-        "nanstd": "std",
+        "min": "min",
+        "max": "max",
+        "mean": "mean",
+        "std": "std",
         "p10": "high_p10",
         "p90": "low_p90",
     }

webviz_subsurface/plugins/_co2_leakage/_utilities/co2volume.py

@@ -623,7 +623,7 @@ def _add_hover_info_in_field(
         for date in dates
     }
     prev_vals = {date: 0 for date in dates}
-    date_dict = spaced_dates(dates, 4)
+    date_dict = spaced_dates(dates, 4)  # type: ignore[arg-type]
     for name, color in zip(cat_ord["type"], colors):
         sub_df = df[df["type"] == name]
         for date in dates:

webviz_subsurface/plugins/_disk_usage.py

@@ -43,15 +43,25 @@ class DiskUsage(WebvizPluginABC):
         self.scratch_dir = scratch_dir
         self.date_input = date
         self.disk_usage = get_disk_usage(self.scratch_dir, self.date_input)
-        self.date = str(self.disk_usage["date"][0])
+
         self.theme = webviz_settings.theme
 
     @property
     def layout(self) -> html.Div:
+        if self.disk_usage.empty:
+            return html.Div(
+                [
+                    wcc.Header(
+                        f"No disk usage data found for {self.scratch_dir}.",
+                        style={"text-align": "center"},
+                    ),
+                ]
+            )
+        date = str(self.disk_usage["date"][0]) if not self.disk_usage.empty else None
         return html.Div(
             [
                 wcc.Header(
-                    f"Disk usage on {self.scratch_dir} per user as of {self.date}",
+                    f"Disk usage on {self.scratch_dir} per user as of {date}",
                     style={"text-align": "center"},
                 ),
                 wcc.FlexBox(
@@ -129,10 +139,10 @@ def get_disk_usage(scratch_dir: Path, date: Optional[str]) -> pd.DataFrame:
         df, date = _loop_dates(scratch_dir)
     else:
         df = _get_disk_usage_for_date(scratch_dir, date)
-        if df is None:
-            raise FileNotFoundError(
-                f"No disk usage file found for {date} in {scratch_dir}."
-            )
+
+        # Return early if no data is found
+        if df.empty:
+            return df
 
     df.rename(
         columns={"usageKB": "usageKiB"}, inplace=True
@@ -174,7 +184,7 @@ def get_disk_usage(scratch_dir: Path, date: Optional[str]) -> pd.DataFrame:
     return df.sort_values(by="usageGiB", axis=0, ascending=False)
 
 
-def _get_disk_usage_for_date(scratch_dir: Path, date: str) -> Optional[pd.DataFrame]:
+def _get_disk_usage_for_date(scratch_dir: Path, date: str) -> pd.DataFrame:
     csv_file = scratch_dir / ".disk_usage" / f"disk_usage_user_test_{date}.csv"
     if csv_file.exists():
         return pd.read_csv(csv_file)
@@ -182,7 +192,8 @@ def _get_disk_usage_for_date(scratch_dir: Path, date: str) -> Optional[pd.DataFr
     csv_file = scratch_dir / ".disk_usage" / f"disk_usage_user_{date}.csv"
     if csv_file.exists():
         return pd.read_csv(csv_file)
-    return None
+    # Create empty DataFrame with expected columns if no file is found
+    return pd.DataFrame(columns=["userid", "usageGiB", "date"])
 
 
 def _loop_dates(scratch_dir: Path) -> Tuple[pd.DataFrame, str]:

webviz_subsurface/plugins/_line_plotter_fmu/controllers/build_figure.py

@@ -256,14 +256,14 @@ def calc_series_statistics(
     stat_df = (
         df[["ENSEMBLE", refaxis] + vectors]
         .groupby(["ENSEMBLE", refaxis])
-        .agg([np.nanmean, np.nanmin, np.nanmax, p10, p90])
+        .agg(["mean", "min", "max", p10, p90])
         .reset_index()  # level=["label", refaxis], col_level=0)
     )
     # Rename nanmin, nanmax and nanmean to min, max and mean.
     col_stat_label_map = {
-        "nanmin": "min",
-        "nanmax": "max",
-        "nanmean": "mean",
+        "min": "min",
+        "max": "max",
+        "mean": "mean",
         "p10": "high_p10",
         "p90": "low_p90",
     }

webviz_subsurface/plugins/_map_viewer_fmu/map_viewer_fmu.py

@@ -106,7 +106,7 @@ color-tables.json for color_tables format.
         rel_surface_folder: str = "share/results/maps",
         color_tables: Path = None,
         hillshading_enabled: bool = None,
-        render_surfaces_as_images: bool = True,
+        render_surfaces_as_images: bool = False,
     ):
         super().__init__()
         self._hillshading = hillshading_enabled

webviz_subsurface/plugins/_parameter_analysis/_types.py

@@ -2,6 +2,7 @@ from webviz_config.utils import StrEnum
 
 
 class VisualizationType(StrEnum):
+    HISTOGRAM = "histogram"
     DISTRIBUTION = "distribution"
     BOX = "box"
     STAT_TABLE = "stat-table"

webviz_subsurface/plugins/_parameter_analysis/_utils/_parameters_model.py

@@ -8,6 +8,8 @@ from webviz_config import WebvizConfigTheme
 from webviz_subsurface._figures import create_figure
 from webviz_subsurface._models.parameter_model import ParametersModel as Pmodel
 
+from .._types import VisualizationType
+
 
 class ParametersModel:
     """Class to process and visualize ensemble parameter data"""
@@ -76,15 +78,15 @@ class ParametersModel:
             .groupby(["ENSEMBLE"])
             .agg(
                 [
-                    ("Avg", np.mean),
-                    ("Stddev", np.std),
+                    ("Avg", "mean"),
+                    ("Stddev", "std"),
                     ("P10", lambda x: np.percentile(x, 10)),
                     ("P90", lambda x: np.percentile(x, 90)),
-                    ("Min", np.min),
-                    ("Max", np.max),
+                    ("Min", "min"),
+                    ("Max", "max"),
                 ]
             )
-            .stack(0)
+            .stack(0, future_stack=True)
             .rename_axis(["ENSEMBLE", "PARAMETER"])
             .reset_index()
         )
@@ -163,7 +165,7 @@ class ParametersModel:
         self,
         ensembles: list,
         parameters: List[Any],
-        plot_type: str = "distribution",
+        plot_type: VisualizationType = VisualizationType.DISTRIBUTION,
     ) -> go.Figure:
         """Create subplots for selected parameters"""
         df = self.dataframe_melted.copy()
@@ -171,7 +173,7 @@ class ParametersModel:
         df = df[df["PARAMETER"].isin(parameters)]
         df = self._sort_parameters_col(df, parameters)
 
-        return (
+        figure = (
             create_figure(
                 plot_type=plot_type,
                 data_frame=df,
@@ -179,6 +181,7 @@ class ParametersModel:
                 facet_col="PARAMETER",
                 color="ENSEMBLE",
                 color_discrete_sequence=self.colorway,
+                barmode="overlay",
             )
             .update_xaxes(matches=None)
             .for_each_trace(
@@ -189,6 +192,11 @@ class ParametersModel:
                 )
             )
         )
+        # Use bingroup=None so that Plotly calculates bins per trace
+        # This also means that individual ensembles will have separate binning.
+        if plot_type == VisualizationType.HISTOGRAM:
+            figure.update_traces(bingroup=None)
+        return figure
 
     def get_stat_value(self, parameter: str, ensemble: str, stat_column: str) -> float:
         """

webviz_subsurface/plugins/_parameter_analysis/_views/_parameter_distributions_view/_settings/_visualization_type.py

@@ -20,6 +20,7 @@ class ParamDistVisualizationType(SettingsGroupABC):
             wcc.RadioItems(
                 id=self.register_component_unique_id(self.Ids.VISUALIZATION_TYPE),
                 options=[
+                    {"label": "Histogram", "value": VisualizationType.HISTOGRAM},
                     {
                         "label": "Distribution plots",
                         "value": VisualizationType.DISTRIBUTION,
@@ -30,7 +31,7 @@ class ParamDistVisualizationType(SettingsGroupABC):
                         "value": VisualizationType.STAT_TABLE,
                     },
                 ],
-                value=VisualizationType.DISTRIBUTION,
+                value=VisualizationType.HISTOGRAM,
                 vertical=True,
             )
         ]

webviz_subsurface/plugins/_property_statistics/property_statistics.py

@@ -61,7 +61,7 @@ FMU format.
 **Using raw ensemble data stored in realization folders**
 * **`ensembles`:** Which ensembles in `shared_settings` to visualize.
 * **`rel_file_pattern`:** path to `.arrow` files with summary data.
-* **`statistic_file`:** Csv file for each realization with property statistics. See the \
+* **`statistics_file`:** Csv file for each realization with property statistics. See the \
     documentation in [fmu-tools](http://fmu-docs.equinor.com/) on how to generate this data.
 * **`column_keys`:** List of vectors to extract. If not given, all vectors \
     from the simulations will be extracted. Wild card asterisk `*` can be used.

webviz_subsurface/plugins/_relative_permeability.py

@@ -982,8 +982,8 @@ def add_statistic_traces(df, color_by, curves, sataxis, colors, nplots):
             ]
             df_stat = (
                 satnum_df_shared_axis.groupby(sataxis)
-                .agg([np.nanmean, np.nanmin, np.nanmax, p10, p90])
-                .stack()
+                .agg(["mean", "min", "max", p10, p90])
+                .stack(future_stack=True)
                 .swaplevel()
             )
             for curve_no, curve in enumerate(curves):
@@ -1032,7 +1032,7 @@ def _get_fanchart_traces(
     """Renders a fanchart"""
 
     # Retrieve indices from one of the keys in series
-    x = curve_stats["nanmax"].index.tolist()
+    x = curve_stats["max"].index.tolist()
     data = FanchartData(
         samples=x,
         low_high=LowHighData(
@@ -1042,10 +1042,10 @@ def _get_fanchart_traces(
             high_name="P10",
         ),
         minimum_maximum=MinMaxData(
-            minimum=curve_stats["nanmin"].values,
-            maximum=curve_stats["nanmax"].values,
+            minimum=curve_stats["min"].values,
+            maximum=curve_stats["max"].values,
         ),
-        free_line=FreeLineData("Mean", curve_stats["nanmean"].values),
+        free_line=FreeLineData("Mean", curve_stats["mean"].values),
     )
 
     hovertemplate = f"{curve} <br>" f"Ensemble: {ens}, Satnum: {satnum}"

webviz_subsurface/plugins/_reservoir_simulation_timeseries_regional.py

@@ -1015,10 +1015,10 @@ def render_table(
                 table.append(
                     {
                         "Group": ens,
-                        "Minimum": df["nanmin"].iat[0],
-                        "Maximum": df["nanmax"].iat[0],
-                        "Mean": df["nanmean"].iat[0],
-                        "Stddev": df["nanstd"].iat[0],
+                        "Minimum": df["min"].iat[0],
+                        "Maximum": df["max"].iat[0],
+                        "Mean": df["mean"].iat[0],
+                        "Stddev": df["std"].iat[0],
                         "P10": df["p10"].iat[0],
                         "P90": df["p90"].iat[0],
                     }
@@ -1031,10 +1031,10 @@ def render_table(
             table.append(
                 {
                     "Group": col.split("_filtered_on_")[-1],
-                    "Minimum": df["nanmin"].iat[0],
-                    "Maximum": df["nanmax"].iat[0],
-                    "Mean": df["nanmean"].iat[0],
-                    "Stddev": df["nanstd"].iat[0],
+                    "Minimum": df["min"].iat[0],
+                    "Maximum": df["max"].iat[0],
+                    "Mean": df["mean"].iat[0],
+                    "Stddev": df["std"].iat[0],
                     "P10": df["p10"].iat[0],
                     "P90": df["p90"].iat[0],
                 }
@@ -1259,7 +1259,7 @@ def calc_statistics(df: pd.DataFrame) -> pd.DataFrame:
         stat_dfs.append(
             ens_df.drop(columns=["REAL", "ENSEMBLE"])
             .groupby("DATE", as_index=False)
-            .agg([np.nanmean, np.nanstd, np.nanmin, np.nanmax, p10, p90])
+            .agg(["mean", "std", "min", "max", p10, p90])
             .reset_index()
             .assign(ENSEMBLE=ens)
         )
@@ -1327,10 +1327,10 @@ def _get_fanchart_traces(
             high_name="P10",
         ),
         minimum_maximum=MinMaxData(
-            minimum=stat_df[column]["nanmin"].values,
-            maximum=stat_df[column]["nanmax"].values,
+            minimum=stat_df[column]["min"].values,
+            maximum=stat_df[column]["max"].values,
         ),
-        free_line=FreeLineData("Mean", stat_df[column]["nanmean"].values),
+        free_line=FreeLineData("Mean", stat_df[column]["mean"].values),
     )
 
     hovertemplate = f"{legend_group}"

webviz_subsurface/plugins/_running_time_analysis_fmu.py

@@ -602,7 +602,12 @@ def make_status_df(
         # Load each json-file to a DataFrame for the realization
         with open(row.FULLPATH) as fjson:
             status_dict = json.load(fjson)
-        real_df = pd.DataFrame(status_dict["jobs"])
+        if "steps" in status_dict:
+            real_df = pd.DataFrame(status_dict["steps"])
+        elif "jobs" in status_dict:
+            real_df = pd.DataFrame(status_dict["jobs"])
+        else:
+            raise KeyError(f"Neither 'steps' nor 'jobs' found in {status_file}")
 
         # If new ensemble, calculate ensemble scaled runtimes
         # for previous ensemble and reset temporary ensemble data