ert 17.1.9__py3-none-any.whl → 18.0.0__py3-none-any.whl

ert/config/rft_config.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import datetime
+import fnmatch
+import logging
+import re
+from collections import defaultdict
+from typing import Literal
+
+import numpy as np
+import numpy.typing as npt
+import polars as pl
+from pydantic import Field
+from resfo_utilities import InvalidRFTError, RFTReader
+
+from ert.substitutions import substitute_runpath_name
+
+from .parsing import ConfigDict, ConfigKeys, ConfigValidationError, ConfigWarning
+from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetadata
+from .responses_index import responses_index
+
+logger = logging.getLogger(__name__)
+
+
+class RFTConfig(ResponseConfig):
+    type: Literal["rft"] = "rft"
+    name: str = "rft"
+    has_finalized_keys: bool = False
+    data_to_read: dict[str, dict[str, list[str]]] = Field(default_factory=dict)
+
+    @property
+    def metadata(self) -> list[ResponseMetadata]:
+        return [
+            ResponseMetadata(
+                response_type=self.name,
+                response_key=response_key,
+                filter_on=None,
+                finalized=self.has_finalized_keys,
+            )
+            for response_key in self.keys
+        ]
+
+    @property
+    def expected_input_files(self) -> list[str]:
+        base = self.input_files[0]
+        if base.upper().endswith(".DATA"):
+            # For backwards compatibility, it is
+            # allowed to give REFCASE and ECLBASE both
+            # with and without .DATA extensions
+            base = base[:-5]
+
+        return [f"{base}.RFT"]
+
+    def read_from_file(self, run_path: str, iens: int, iter_: int) -> pl.DataFrame:
+        filename = substitute_runpath_name(self.input_files[0], iens, iter_)
+        if filename.upper().endswith(".DATA"):
+            # For backwards compatibility, it is
+            # allowed to give REFCASE and ECLBASE both
+            # with and without .DATA extensions
+            filename = filename[:-5]
+        fetched: dict[tuple[str, datetime.date], dict[str, npt.NDArray[np.float32]]] = (
+            defaultdict(dict)
+        )
+        # This is a somewhat complicated optimization in order to
+        # support wildcards in well names, dates and properties
+        # A python for loop is too slow so we use a compiled regex
+        # instead
+        if not self.data_to_read:
+            return pl.DataFrame(
+                {
+                    "response_key": [],
+                    "time": [],
+                    "depth": [],
+                    "values": [],
+                }
+            )
+
+        sep = "\x31"
+
+        def _translate(pat: str) -> str:
+            """Translates fnmatch pattern to match anywhere"""
+            return fnmatch.translate(pat).replace("\\z", "").replace("\\Z", "")
+
+        def _props_matcher(props: list[str]) -> str:
+            """Regex for matching given props _and_ DEPTH"""
+            pattern = f"({'|'.join(_translate(p) for p in props)})"
+            if re.fullmatch(pattern, "DEPTH") is None:
+                return f"({'|'.join(_translate(p) for p in [*props, 'DEPTH'])})"
+            else:
+                return pattern
+
+        matcher = re.compile(
+            "|".join(
+                "("
+                + re.escape(sep).join(
+                    (
+                        _translate(well),
+                        _translate(time),
+                        _props_matcher(props),
+                    )
+                )
+                + ")"
+                for well, inner_dict in self.data_to_read.items()
+                for time, props in inner_dict.items()
+            )
+        )
+        try:
+            with RFTReader.open(f"{run_path}/{filename}") as rft:
+                for entry in rft:
+                    date = entry.date
+                    well = entry.well
+                    for rft_property in entry:
+                        key = f"{well}{sep}{date}{sep}{rft_property}"
+                        if matcher.fullmatch(key) is not None:
+                            values = entry[rft_property]
+                            if np.isdtype(values.dtype, np.float32):
+                                fetched[well, date][rft_property] = values
+        except (FileNotFoundError, InvalidRFTError) as err:
+            raise InvalidResponseFile(
+                f"Could not read RFT from {run_path}/{filename}: {err}"
+            ) from err
+
+        if not fetched:
+            return pl.DataFrame(
+                {
+                    "response_key": [],
+                    "time": [],
+                    "depth": [],
+                    "values": [],
+                }
+            )
+
+        dfs = []
+
+        for (well, time), inner_dict in fetched.items():
+            wide = pl.DataFrame(
+                {k: pl.Series(v.astype("<f4")) for k, v in inner_dict.items()}
+            )
+
+            if wide.columns == ["DEPTH"]:
+                continue
+
+            if "DEPTH" not in wide.columns:
+                raise InvalidResponseFile(f"Could not find DEPTH in RFTFile {filename}")
+
+            # Unpivot all columns except DEPTH
+            long = wide.unpivot(
+                index="DEPTH",  # keep depth as column
+                # turn other prop values into response_key col
+                variable_name="response_key",
+                value_name="values",  # put values in own column
+            ).rename({"DEPTH": "depth"})
+
+            # Add wellname prefix to response_keys
+            long = long.with_columns(
+                (pl.lit(f"{well}:{time.isoformat()}:") + pl.col("response_key")).alias(
+                    "response_key"
+                ),
+                pl.lit(time).alias("time"),
+            )
+
+            dfs.append(long.select("response_key", "time", "depth", "values"))
+
+        return pl.concat(dfs)
+
+    @property
+    def response_type(self) -> str:
+        return "rft"
+
+    @property
+    def primary_key(self) -> list[str]:
+        return []
+
+    @classmethod
+    def from_config_dict(cls, config_dict: ConfigDict) -> RFTConfig | None:
+        if rfts := config_dict.get(ConfigKeys.RFT, []):
+            eclbase: str | None = config_dict.get("ECLBASE")
+            if eclbase is None:
+                raise ConfigValidationError(
+                    "In order to use rft responses, ECLBASE has to be set."
+                )
+            fm_steps = config_dict.get(ConfigKeys.FORWARD_MODEL, [])
+            names = [fm_step[0] for fm_step in fm_steps]
+            simulation_step_exists = any(
+                any(sim in name.lower() for sim in ["eclipse", "flow"])
+                for name in names
+            )
+            if not simulation_step_exists:
+                ConfigWarning.warn(
+                    "Config contains a RFT key but no forward model "
+                    "step known to generate rft files"
+                )
+
+            declared_data: dict[str, dict[datetime.date, list[str]]] = defaultdict(
+                lambda: defaultdict(list)
+            )
+            for rft in rfts:
+                for expected in ["WELL", "DATE", "PROPERTIES"]:
+                    if expected not in rft:
+                        raise ConfigValidationError.with_context(
+                            f"For RFT keyword {expected} must be specified.", rft
+                        )
+                well = rft["WELL"]
+                props = [p.strip() for p in rft["PROPERTIES"].split(",")]
+                time = rft["DATE"]
+                declared_data[well][time] += props
+            data_to_read = {
+                well: {time: sorted(set(p)) for time, p in inner_dict.items()}
+                for well, inner_dict in declared_data.items()
+            }
+            keys = sorted(
+                {
+                    f"{well}:{time}:{p}"
+                    for well, inner_dict in declared_data.items()
+                    for time, props in inner_dict.items()
+                    for p in props
+                }
+            )
+
+            return cls(
+                name="rft",
+                input_files=[eclbase.replace("%d", "<IENS>")],
+                keys=keys,
+                data_to_read=data_to_read,
+            )
+
+        return None
+
+
+responses_index.add_response_type(RFTConfig)

ert/config/summary_config.py

@@ -72,10 +72,6 @@ class SummaryConfig(ResponseConfig):
         df = df.sort(by=["time"])
         return df
 
-    @property
-    def response_type(self) -> str:
-        return "summary"
-
     @property
     def primary_key(self) -> list[str]:
         return ["time"]
@@ -91,8 +87,8 @@ class SummaryConfig(ResponseConfig):
             fm_steps = config_dict.get(ConfigKeys.FORWARD_MODEL, [])
             names = [fm_step[0] for fm_step in fm_steps]
             simulation_step_exists = any(
-                any(sim in _name.lower() for sim in ["eclipse", "flow"])
-                for _name in names
+                any(sim in name.lower() for sim in ["eclipse", "flow"])
+                for name in names
             )
             if not simulation_step_exists:
                 ConfigWarning.warn(

ert/config/workflow_fixtures.py

@@ -6,12 +6,13 @@ import typing
 from dataclasses import dataclass, fields
 from typing import TYPE_CHECKING, Literal
 
-from PyQt6.QtWidgets import QWidget
 from typing_extensions import TypedDict
 
 from ert.config.parsing.hook_runtime import HookRuntime
 
 if TYPE_CHECKING:
+    from PyQt6.QtWidgets import QWidget
+
     from ert.config import ESSettings, ObservationSettings
     from ert.runpaths import Runpaths
     from ert.storage import Ensemble, Storage

ert/dark_storage/client/__init__.py

@@ -1,4 +1,4 @@
-from ._session import ConnInfo
+from ._session import ErtClientConnectionInfo
 from .client import Client
 
-__all__ = ["Client", "ConnInfo"]
+__all__ = ["Client", "ErtClientConnectionInfo"]

ert/dark_storage/client/_session.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from pydantic import BaseModel, ValidationError
 
 
-class ConnInfo(BaseModel):
+class ErtClientConnectionInfo(BaseModel):
     base_url: str
     auth_token: str | None = None
     cert: str | bool = False
@@ -17,10 +17,10 @@ ENV_VAR = "ERT_STORAGE_CONNECTION_STRING"
 # that a single client process will only ever want to connect to a single ERT
 # Storage server during its lifetime, so we don't provide an API for managing
 # this cache.
-_CACHED_CONN_INFO: ConnInfo | None = None
+_CACHED_CONN_INFO: ErtClientConnectionInfo | None = None
 
 
-def find_conn_info() -> ConnInfo:
+def find_conn_info() -> ErtClientConnectionInfo:
     """
     The base url and auth token are read from either:
     The file `storage_server.json`, starting from the current working directory
@@ -54,7 +54,7 @@ def find_conn_info() -> ConnInfo:
         raise RuntimeError("No Storage connection configuration found")
 
     try:
-        conn_info = ConnInfo.model_validate_json(conn_str)
+        conn_info = ErtClientConnectionInfo.model_validate_json(conn_str)
     except (json.JSONDecodeError, ValidationError) as e:
         raise RuntimeError("Invalid storage connection configuration") from e
     else:

ert/dark_storage/client/client.py

@@ -3,7 +3,7 @@ import ssl
 import httpx
 from httpx_retries import Retry, RetryTransport
 
-from ._session import ConnInfo, find_conn_info
+from ._session import ErtClientConnectionInfo, find_conn_info
 
 
 class Client(httpx.Client):
@@ -14,7 +14,7 @@ class Client(httpx.Client):
     Stores 'conn_info' to bridge the gap to the Everest client setup
     """
 
-    def __init__(self, conn_info: ConnInfo | None = None) -> None:
+    def __init__(self, conn_info: ErtClientConnectionInfo | None = None) -> None:
         if conn_info is None:
             conn_info = find_conn_info()
 

ert/dark_storage/compute/misfits.py

@@ -5,17 +5,18 @@ import numpy.typing as npt
 import pandas as pd
 
 
-def _calculate_misfit(
+def _calculate_signed_chi_squared_misfit(
     obs_value: npt.NDArray[np.float64],
     response_value: npt.NDArray[np.float64],
     obs_std: npt.NDArray[np.float64],
 ) -> list[float]:
-    difference = response_value - obs_value
-    misfit = (difference / obs_std) ** 2
-    return (misfit * np.sign(difference)).tolist()
+    """The signed version is intended for visualization. For data assimiliation one
+    would normally use the normal chi-square"""
+    residual = response_value - obs_value
+    return (np.sign(residual) * residual * residual / (obs_std * obs_std)).tolist()
 
 
-def calculate_misfits_from_pandas(
+def calculate_signed_chi_squared_misfits(
     reponses_dict: Mapping[int, pd.DataFrame],
     observation: pd.DataFrame,
     summary_misfits: bool = False,
@@ -26,7 +27,7 @@ def calculate_misfits_from_pandas(
     """
     misfits_dict = {}
     for realization_index in reponses_dict:
-        misfits_dict[realization_index] = _calculate_misfit(
+        misfits_dict[realization_index] = _calculate_signed_chi_squared_misfit(
             observation["values"],
             reponses_dict[realization_index].loc[:, observation.index].values.flatten(),
             observation["errors"],

ert/dark_storage/endpoints/compute/misfits.py

@@ -10,7 +10,7 @@ from fastapi.responses import Response
 
 from ert.dark_storage import exceptions as exc
 from ert.dark_storage.common import get_storage
-from ert.dark_storage.compute.misfits import calculate_misfits_from_pandas
+from ert.dark_storage.compute.misfits import calculate_signed_chi_squared_misfits
 from ert.dark_storage.endpoints.observations import (
     _get_observations,
 )
@@ -80,7 +80,7 @@ async def get_response_misfits(
         index=[parse_index(x) for x in o["x_axis"]],
     )
     try:
-        result_df = calculate_misfits_from_pandas(
+        result_df = calculate_signed_chi_squared_misfits(
             response_dict, observation_df, summary_misfits
         )
     except Exception as misfits_exc:

ert/dark_storage/endpoints/observations.py

@@ -136,13 +136,13 @@ def _get_observations(
         df = df.with_columns(pl.Series(name="x_axis", values=df.map_rows(x_axis_fn)))
         df = df.sort("x_axis")
 
-        for obs_key, _obs_df in df.group_by("name"):
+        for obs_key, obs_df in df.group_by("name"):
             observations.append(
                 {
                     "name": obs_key[0],
-                    "values": _obs_df["values"].to_list(),
-                    "errors": _obs_df["errors"].to_list(),
-                    "x_axis": _obs_df["x_axis"].to_list(),
+                    "values": obs_df["values"].to_list(),
+                    "errors": obs_df["errors"].to_list(),
+                    "x_axis": obs_df["x_axis"].to_list(),
                 }
             )
 

ert/dark_storage/endpoints/responses.py

@@ -116,7 +116,7 @@ def _extract_response_type_and_key(
 
 def data_for_response(
     ensemble: Ensemble, key: str, filter_on: dict[str, Any] | None = None
-) -> pd.DataFrame:
+) -> pd.DataFrame | pd.Series:
     response_key, response_type = _extract_response_type_and_key(
         key, ensemble.experiment.response_key_to_response_type
     )
@@ -151,6 +151,19 @@ def data_for_response(
         data.columns = data.columns.droplevel(0)
         return data.astype(float)
 
+    if response_type == "rft":
+        return (
+            ensemble.load_responses(
+                response_key,
+                tuple(realizations_with_responses),
+            )
+            .rename({"realization": "Realization"})
+            .select(["Realization", "depth", "values"])
+            .to_pandas()
+            .pivot(index="Realization", columns="depth", values="values")
+            .reset_index(drop=True)
+        )
+
     if response_type == "gen_data":
         data = ensemble.load_responses(response_key, tuple(realizations_with_responses))
 
@@ -169,3 +182,4 @@ def data_for_response(
 
         except (ValueError, KeyError, ColumnNotFoundError):
             return pd.DataFrame()
+    return pd.DataFrame()

ert/ensemble_evaluator/__init__.py

@@ -2,7 +2,13 @@ from ._ensemble import LegacyEnsemble as Ensemble
 from ._ensemble import Realization
 from .config import EvaluatorServerConfig
 from .evaluator import EnsembleEvaluator
-from .event import EndEvent, FullSnapshotEvent, SnapshotUpdateEvent, WarningEvent
+from .event import (
+    EndEvent,
+    FullSnapshotEvent,
+    SnapshotUpdateEvent,
+    StartEvent,
+    WarningEvent,
+)
 from .snapshot import EnsembleSnapshot, FMStepSnapshot, RealizationSnapshot
 
 __all__ = [
@@ -16,5 +22,6 @@ __all__ = [
     "Realization",
     "RealizationSnapshot",
     "SnapshotUpdateEvent",
+    "StartEvent",
     "WarningEvent",
 ]

ert/ensemble_evaluator/evaluator.py

@@ -6,6 +6,8 @@ import threading
 import traceback
 from collections import defaultdict
 from collections.abc import Awaitable, Callable, Iterable, Sequence
+from dataclasses import dataclass
+from math import ceil
 from typing import Any, cast, get_args
 
 import zmq.asyncio
@@ -15,6 +17,7 @@ from _ert.events import (
     EESnapshot,
     EESnapshotUpdate,
     EnsembleCancelled,
+    EnsembleEvaluationWarning,
     EnsembleFailed,
     EnsembleStarted,
     EnsembleSucceeded,
@@ -49,6 +52,13 @@ from .state import (
     ENSEMBLE_STATE_STOPPED,
 )
 
+
+@dataclass(order=True)
+class ParallelismViolation:
+    amount: float = 0
+    message: str = ""
+
+
 logger = logging.getLogger(__name__)
 
 EVENT_HANDLER = Callable[[list[SnapshotInputEvent]], Awaitable[None]]
@@ -68,6 +78,13 @@ class EventSentinel:
 
 class EnsembleEvaluator:
     BATCHING_INTERVAL = 0.5
+    DEFAULT_SLEEP_PERIOD = 0.1
+
+    # These properties help us determine whether the user
+    # has misconfigured NUM_CPU in their config.
+    ALLOWED_CPU_OVERSPENDING = 1.05
+    MINIMUM_WALLTIME_SECONDS = 30  # Information is only polled every 5 sec
+    CPU_OVERSPENDING_WARNING_THRESHOLD = 1.50
 
     def __init__(
         self,
@@ -123,6 +140,7 @@ class EnsembleEvaluator:
             submit_sleep=self.ensemble._queue_config.submit_sleep,
             ens_id=self.ensemble.id_,
         )
+        self.max_parallelism_violation = ParallelismViolation()
 
     async def _publisher(self) -> None:
         heartbeat_interval = 0.1
@@ -145,6 +163,11 @@ class EnsembleEvaluator:
                         self._evaluation_result.set_result(True)
                     return
 
+                elif isinstance(event, EnsembleEvaluationWarning):
+                    if self._event_handler:
+                        self._event_handler(event)
+                    self._events_to_send.task_done()
+
                 elif type(event) in {
                     EESnapshot,
                     EESnapshotUpdate,
@@ -191,7 +214,7 @@ class EnsembleEvaluator:
                 await self._signal_cancel()
                 logger.debug("Run model cancelled - during evaluation - cancel sent")
                 self._end_event.clear()
-            await asyncio.sleep(0.1)
+            await asyncio.sleep(self.DEFAULT_SLEEP_PERIOD)
 
     async def _send_terminate_message_to_dispatchers(self) -> None:
         event = TERMINATE_MSG
@@ -244,6 +267,7 @@ class EnsembleEvaluator:
                 event_handler[event_type] = func
 
         set_event_handler(set(get_args(FMEvent | RealizationEvent)), self._fm_handler)
+        set_event_handler({EnsembleEvaluationWarning}, self._warning_event_handler)
         set_event_handler({EnsembleStarted}, self._started_handler)
         set_event_handler({EnsembleSucceeded}, self._stopped_handler)
         set_event_handler({EnsembleCancelled}, self._cancelled_handler)
@@ -264,7 +288,7 @@ class EnsembleEvaluator:
                     batch.append((function, event))
                     self._events.task_done()
                 except asyncio.QueueEmpty:
-                    await asyncio.sleep(0.1)
+                    await asyncio.sleep(self.DEFAULT_SLEEP_PERIOD)
                     continue
             self._complete_batch.set()
             await self._batch_processing_queue.put(batch)
@@ -274,6 +298,12 @@ class EnsembleEvaluator:
     async def _fm_handler(self, events: Sequence[FMEvent | RealizationEvent]) -> None:
         await self._append_message(self.ensemble.update_snapshot(events))
 
+    async def _warning_event_handler(
+        self, events: Sequence[EnsembleEvaluationWarning]
+    ) -> None:
+        for event in events:
+            await self._events_to_send.put(event)
+
     async def _started_handler(self, events: Sequence[EnsembleStarted]) -> None:
         if self.ensemble.status != ENSEMBLE_STATE_FAILED:
             await self._append_message(self.ensemble.update_snapshot(events))
@@ -288,11 +318,9 @@ class EnsembleEvaluator:
             memory_usage = fm_step.get(ids.MAX_MEMORY_USAGE) or "-1"
             max_memory_usage = max(int(memory_usage), max_memory_usage)
 
-            cpu_message = detect_overspent_cpu(
+            self.detect_overspent_cpu(
                 self.ensemble.reals[int(real_id)].num_cpu, real_id, fm_step
             )
-            if self.ensemble.queue_system != QueueSystem.LOCAL and cpu_message:
-                logger.warning(cpu_message)
 
         logger.info(
             "Ensemble ran with maximum memory usage for a "
@@ -368,6 +396,7 @@ class EnsembleEvaluator:
                     logger.warning(
                         "Evaluator receiver closed, no new messages are received"
                     )
+                    return  # The socket is closed, and we won't re-establish it.
                 else:
                     logger.error(f"Unexpected error when listening to messages: {e}")
             except asyncio.CancelledError:
@@ -416,7 +445,7 @@ class EnsembleEvaluator:
             while True:
                 if self._evaluation_result.done():
                     break
-                await asyncio.sleep(0.1)
+                await asyncio.sleep(self.DEFAULT_SLEEP_PERIOD)
             logger.debug("Async server exiting.")
         finally:
             try:
@@ -647,27 +676,50 @@ class EnsembleEvaluator:
         else:
             await self._events.put(EnsembleCancelled(ensemble=self.ensemble.id_))
 
-
-def detect_overspent_cpu(num_cpu: int, real_id: str, fm_step: FMStepSnapshot) -> str:
-    """Produces a message warning about misconfiguration of NUM_CPU if
-    so is detected. Returns an empty string if everything is ok."""
-    allowed_overspending = 1.05
-    minimum_wallclock_time_seconds = 30  # Information is only polled every 5 sec
-
-    start_time = fm_step.get(ids.START_TIME)
-    end_time = fm_step.get(ids.END_TIME)
-    if start_time is None or end_time is None:
-        return ""
-    duration = (end_time - start_time).total_seconds()
-    if duration <= minimum_wallclock_time_seconds:
-        return ""
-    cpu_seconds = fm_step.get(ids.CPU_SECONDS) or 0.0
-    parallelization_obtained = cpu_seconds / duration
-    if parallelization_obtained > num_cpu * allowed_overspending:
-        return (
-            f"Misconfigured NUM_CPU, forward model step '{fm_step.get(ids.NAME)}' for "
-            f"realization {real_id} spent {cpu_seconds} cpu seconds "
-            f"with wall clock duration {duration:.1f} seconds, "
-            f"a factor of {parallelization_obtained:.2f}, while NUM_CPU was {num_cpu}."
+    def detect_overspent_cpu(
+        self, num_cpu: int, real_id: str, fm_step: FMStepSnapshot
+    ) -> None:
+        """Produces a message warning about misconfiguration of NUM_CPU if
+        so is detected. Returns an empty string if everything is ok."""
+        allowed_overspending = self.ALLOWED_CPU_OVERSPENDING * num_cpu
+        overspending_warning_threshold = (
+            self.CPU_OVERSPENDING_WARNING_THRESHOLD * num_cpu
         )
-    return ""
+
+        start_time = fm_step.get(ids.START_TIME)
+
+        end_time = fm_step.get(ids.END_TIME)
+        if start_time is None or end_time is None:
+            return
+
+        duration = (end_time - start_time).total_seconds()
+        if duration <= self.MINIMUM_WALLTIME_SECONDS:
+            return
+
+        cpu_seconds = fm_step.get(ids.CPU_SECONDS) or 0.0
+        parallelization_obtained = cpu_seconds / duration
+        if (
+            parallelization_obtained > allowed_overspending
+            and self.ensemble.queue_system != QueueSystem.LOCAL
+        ):
+            logger.warning(
+                f"Misconfigured NUM_CPU, forward model step '{fm_step.get(ids.NAME)}' "
+                f"for realization {real_id} spent {cpu_seconds} cpu seconds "
+                f"with wall clock duration {duration:.1f} seconds, a factor of "
+                f"{parallelization_obtained:.2f}, while NUM_CPU was {num_cpu}."
+            )
+            if parallelization_obtained > overspending_warning_threshold:
+                warning_msg = (
+                    "Overusage of CPUs detected!\n"
+                    f"Your experiment has used up to {ceil(parallelization_obtained)} "
+                    f"CPUs in step '{fm_step.get(ids.NAME)}', "
+                    f"while the Ert config has only requested {num_cpu}.\n"
+                    f"This means your experiment is consuming more CPU-resources than "
+                    f"requested and will slow down other users experiments.\n"
+                    f"We kindly ask you to set "
+                    f"NUM_CPU={ceil(parallelization_obtained)} in your Ert config."
+                )
+                self.max_parallelism_violation = max(
+                    self.max_parallelism_violation,
+                    ParallelismViolation(parallelization_obtained, warning_msg),
+                )

ert/ensemble_evaluator/event.py

@@ -1,4 +1,5 @@
 from collections.abc import Mapping
+from datetime import datetime
 from typing import Any, Literal
 
 from pydantic import BaseModel, ConfigDict, field_serializer, field_validator
@@ -42,6 +43,11 @@ class SnapshotUpdateEvent(_UpdateEvent):
     event_type: Literal["SnapshotUpdateEvent"] = "SnapshotUpdateEvent"
 
 
+class StartEvent(BaseModel):
+    event_type: Literal["StartEvent"] = "StartEvent"
+    timestamp: datetime
+
+
 class EndEvent(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")
     event_type: Literal["EndEvent"] = "EndEvent"