ert 16.0.9__py3-none-any.whl → 19.0.0rc2__py3-none-any.whl

ert/config/__init__.py

@@ -11,9 +11,8 @@ from .ensemble_config import EnsembleConfig
 from .ert_config import ErtConfig, forward_model_step_from_config_contents
 from .ert_plugin import ErtPlugin
 from .ert_script import ErtScript
-from .everest_constraints_config import EverestConstraintsConfig
-from .everest_objective_config import EverestObjectivesConfig
-from .ext_param_config import ExtParamConfig
+from .everest_control import EverestControl, SamplerConfig
+from .everest_response import EverestConstraintsConfig, EverestObjectivesConfig
 from .external_ert_script import ExternalErtScript
 from .field import Field, field_transform
 from .forward_model_step import (
@@ -23,12 +22,16 @@ from .forward_model_step import (
     ForwardModelStepPlugin,
     ForwardModelStepValidationError,
     ForwardModelStepWarning,
+    SiteInstalledForwardModelStep,
+    SiteOrUserForwardModelStep,
+    UserInstalledForwardModelStep,
 )
 from .gen_data_config import GenDataConfig
 from .gen_kw_config import DataSource, GenKwConfig, PriorDict
+from .known_response_types import KnownResponseTypes
 from .lint_file import lint_file
 from .model_config import ModelConfig
-from .parameter_config import ParameterCardinality, ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterCardinality, ParameterConfig
 from .parsing import (
     ConfigValidationError,
     ConfigWarning,
@@ -45,6 +48,7 @@ from .queue_config import (
     QueueConfig,
 )
 from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetadata
+from .rft_config import RFTConfig
 from .summary_config import SummaryConfig
 from .surface_config import SurfaceConfig
 from .workflow import Workflow
@@ -63,6 +67,7 @@ from .workflow_fixtures import (
     fixtures_per_hook,
 )
 from .workflow_job import (
+    BaseErtScriptWorkflow,
     ErtScriptWorkflow,
     ExecutableWorkflow,
     WorkflowJob,
@@ -72,6 +77,7 @@ from .workflow_job import (
 __all__ = [
     "AnalysisConfig",
     "AnalysisModule",
+    "BaseErtScriptWorkflow",
     "ConfigValidationError",
     "ConfigWarning",
     "DataSource",
@@ -84,9 +90,9 @@ __all__ = [
     "ErtScript",
     "ErtScriptWorkflow",
     "EverestConstraintsConfig",
+    "EverestControl",
     "EverestObjectivesConfig",
     "ExecutableWorkflow",
-    "ExtParamConfig",
     "ExternalErtScript",
     "Field",
     "ForwardModelStep",
@@ -103,6 +109,7 @@ __all__ = [
     "InversionTypeES",
     "KnownQueueOptions",
     "KnownQueueOptionsAdapter",
+    "KnownResponseTypes",
     "LegacyWorkflowConfigs",
     "LocalQueueOptions",
     "ModelConfig",
@@ -112,7 +119,6 @@ __all__ = [
     "OutlierSettings",
     "ParameterCardinality",
     "ParameterConfig",
-    "ParameterMetadata",
     "PostExperimentFixtures",
     "PostSimulationFixtures",
     "PostUpdateFixtures",
@@ -123,10 +129,15 @@ __all__ = [
     "PriorDict",
     "QueueConfig",
     "QueueSystem",
+    "RFTConfig",
     "ResponseConfig",
     "ResponseMetadata",
+    "SamplerConfig",
+    "SiteInstalledForwardModelStep",
+    "SiteOrUserForwardModelStep",
     "SummaryConfig",
     "SurfaceConfig",
+    "UserInstalledForwardModelStep",
     "WarningInfo",
     "Workflow",
     "WorkflowConfigs",

ert/config/_create_observation_dataframes.py

@@ -7,8 +7,8 @@ from typing import TYPE_CHECKING, Any, assert_never
 
 import numpy as np
 import polars as pl
+from resfo_utilities import history_key
 
-from ert.summary_key_type import history_key
 from ert.validation import rangestring_to_list
 
 from ._observations import (
@@ -18,6 +18,7 @@ from ._observations import (
     Observation,
     ObservationDate,
     ObservationError,
+    RFTObservation,
     SummaryObservation,
 )
 from .gen_data_config import GenDataConfig
@@ -28,18 +29,21 @@ from .parsing import (
     ObservationConfigError,
 )
 from .refcase import Refcase
+from .rft_config import RFTConfig
 
 if TYPE_CHECKING:
     import numpy.typing as npt
 
 
 DEFAULT_TIME_DELTA = timedelta(seconds=30)
+DEFAULT_LOCATION_RANGE_M = 3000
 
 
 def create_observation_dataframes(
     observations: Sequence[Observation],
     refcase: Refcase | None,
     gen_data_config: GenDataConfig | None,
+    rft_config: RFTConfig | None,
     time_map: list[datetime] | None,
     history: HistorySource,
 ) -> dict[str, pl.DataFrame]:
@@ -55,7 +59,6 @@ def create_observation_dataframes(
     config_errors: list[ErrorInfo] = []
     grouped: dict[str, list[pl.DataFrame]] = defaultdict(list)
     for obs in observations:
-        obs_name = obs.name
         try:
             match obs:
                 case HistoryObservation():
@@ -63,7 +66,7 @@ def create_observation_dataframes(
                         _handle_history_observation(
                             refcase,
                             obs,
-                            obs_name,
+                            obs.name,
                             history,
                             time_len,
                         )
@@ -72,7 +75,7 @@ def create_observation_dataframes(
                     grouped["summary"].append(
                         _handle_summary_observation(
                             obs,
-                            obs_name,
+                            obs.name,
                             obs_time_list,
                             bool(refcase),
                         )
@@ -82,11 +85,18 @@ def create_observation_dataframes(
                         _handle_general_observation(
                             gen_data_config,
                             obs,
-                            obs_name,
+                            obs.name,
                             obs_time_list,
                             bool(refcase),
                         )
                     )
+                case RFTObservation():
+                    if rft_config is None:
+                        raise TypeError(
+                            "create_observation_dataframes requires "
+                            "rft_config is not None when using RFTObservation"
+                        )
+                    grouped["rft"].append(_handle_rft_observation(rft_config, obs))
                 case default:
                     assert_never(default)
         except ObservationConfigError as err:
@@ -286,6 +296,43 @@ def _get_restart(
         ) from err
 
 
+def _has_localization(summary_dict: SummaryObservation) -> bool:
+    return any(
+        [
+            summary_dict.location_x is not None,
+            summary_dict.location_y is not None,
+            summary_dict.location_range is not None,
+        ]
+    )
+
+
+def _validate_localization_values(summary_dict: SummaryObservation) -> None:
+    """The user must provide LOCATION_X and LOCATION_Y to use localization, while
+    unprovided LOCATION_RANGE should default to some value.
+
+    This method assumes the summary dict contains at least one LOCATION key.
+    """
+    if summary_dict.location_x is None or summary_dict.location_y is None:
+        loc_values = {
+            "LOCATION_X": summary_dict.location_x,
+            "LOCATION_Y": summary_dict.location_y,
+            "LOCATION_RANGE": summary_dict.location_range,
+        }
+        provided_loc_values = {k: v for k, v in loc_values.items() if v is not None}
+
+        provided_loc_values_string = ", ".join(
+            key.upper() for key in provided_loc_values
+        )
+        raise ObservationConfigError.with_context(
+            f"Localization for observation {summary_dict.name} is misconfigured.\n"
+            f"Only {provided_loc_values_string} were provided. To enable "
+            f"localization for an observation, ensure that both LOCATION_X and "
+            f"LOCATION_Y are defined - or remove LOCATION keywords to disable "
+            f"localization.",
+            summary_dict,
+        )
+
+
 def _handle_summary_observation(
     summary_dict: SummaryObservation,
     obs_key: str,
@@ -323,15 +370,23 @@ def _handle_summary_observation(
             "Observation uncertainty must be strictly > 0", summary_key
         ) from None
 
-    return pl.DataFrame(
-        {
-            "response_key": [summary_key],
-            "observation_key": [obs_key],
-            "time": pl.Series([date]).dt.cast_time_unit("ms"),
-            "observations": pl.Series([value], dtype=pl.Float32),
-            "std": pl.Series([std_dev], dtype=pl.Float32),
-        }
-    )
+    data_dict = {
+        "response_key": [summary_key],
+        "observation_key": [obs_key],
+        "time": pl.Series([date]).dt.cast_time_unit("ms"),
+        "observations": pl.Series([value], dtype=pl.Float32),
+        "std": pl.Series([std_dev], dtype=pl.Float32),
+    }
+
+    if _has_localization(summary_dict):
+        _validate_localization_values(summary_dict)
+        data_dict["location_x"] = summary_dict.location_x
+        data_dict["location_y"] = summary_dict.location_y
+        data_dict["location_range"] = (
+            summary_dict.location_range or DEFAULT_LOCATION_RANGE_M
+        )
+
+    return pl.DataFrame(data_dict)
 
 
 def _handle_general_observation(
@@ -414,10 +469,8 @@ def _handle_general_observation(
         stds = file_values[1::2]
 
     else:
-        assert (
-            general_observation.value is not None
-            and general_observation.error is not None
-        )
+        assert general_observation.value is not None
+        assert general_observation.error is not None
         values = np.array([general_observation.value])
         stds = np.array([general_observation.error])
 
@@ -439,9 +492,11 @@ def _handle_general_observation(
         raise ObservationConfigError.with_context(
             f"Values ({values}), error ({stds}) and "
             f"index list ({indices}) must be of equal length",
-            general_observation.obs_file
-            if general_observation.obs_file is not None
-            else "",
+            (
+                general_observation.obs_file
+                if general_observation.obs_file is not None
+                else ""
+            ),
         )
 
     if np.any(stds <= 0):
@@ -461,3 +516,45 @@ def _handle_general_observation(
             "std": pl.Series(stds, dtype=pl.Float32),
         }
     )
+
+
+def _handle_rft_observation(
+    rft_config: RFTConfig,
+    rft_observation: RFTObservation,
+) -> pl.DataFrame:
+    location = (rft_observation.east, rft_observation.north, rft_observation.tvd)
+    if location not in rft_config.locations:
+        rft_config.locations.append(location)
+
+    data_to_read = rft_config.data_to_read
+    if rft_observation.well not in data_to_read:
+        rft_config.data_to_read[rft_observation.well] = {}
+
+    well_dict = data_to_read[rft_observation.well]
+    if rft_observation.date not in well_dict:
+        well_dict[rft_observation.date] = []
+
+    property_list = well_dict[rft_observation.date]
+    if rft_observation.property not in property_list:
+        property_list.append(rft_observation.property)
+
+    if rft_observation.error <= 0.0:
+        raise ObservationConfigError.with_context(
+            "Observation uncertainty must be strictly > 0", rft_observation.well
+        )
+
+    return pl.DataFrame(
+        {
+            "response_key": (
+                f"{rft_observation.well}:"
+                f"{rft_observation.date}:"
+                f"{rft_observation.property}"
+            ),
+            "observation_key": rft_observation.name,
+            "east": pl.Series([location[0]], dtype=pl.Float32),
+            "north": pl.Series([location[1]], dtype=pl.Float32),
+            "tvd": pl.Series([location[2]], dtype=pl.Float32),
+            "observations": pl.Series([rft_observation.value], dtype=pl.Float32),
+            "std": pl.Series([rft_observation.error], dtype=pl.Float32),
+        }
+    )

ert/config/_get_num_cpu.py

@@ -156,7 +156,7 @@ class _Parser:
     def next_line(self) -> Iterator[str]: ...
 
     @overload
-    def next_line(self, __default: T) -> Iterator[str] | T: ...
+    def next_line(self, __default: T, /) -> Iterator[str] | T: ...
 
     def next_line(self, *args: T) -> Iterator[str] | T:
         self.line_number += 1

ert/config/_observations.py

@@ -90,10 +90,13 @@ class _SummaryValues:
     name: str
     value: float
     key: str  #: The :term:`summary key` in the summary response
+    location_x: float | None = None
+    location_y: float | None = None
+    location_range: float | None = None
 
 
 @dataclass
-class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
+class SummaryObservation(ObservationDate, _SummaryValues, ObservationError):
     @classmethod
     def from_obs_dict(cls, directory: str, observation_dict: ObservationDict) -> Self:
         error_mode = ErrorModes.ABS
@@ -101,6 +104,7 @@ class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
 
         date_dict: ObservationDate = ObservationDate()
         float_values: dict[str, float] = {"ERROR_MIN": 0.1}
+        localization_values: dict[str, float] = {}
         for key, value in observation_dict.items():
             match key:
                 case "type" | "name":
@@ -121,6 +125,12 @@ class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
                     summary_key = value
                 case "DATE":
                     date_dict.date = value
+                case "LOCATION_X":
+                    localization_values["x"] = validate_float(value, key)
+                case "LOCATION_Y":
+                    localization_values["y"] = validate_float(value, key)
+                case "LOCATION_RANGE":
+                    localization_values["range"] = validate_float(value, key)
                 case _:
                     raise _unknown_key_error(str(key), observation_dict["name"])
         if "VALUE" not in float_values:
@@ -137,6 +147,9 @@ class SummaryObservation(ObservationDate, ObservationError, _SummaryValues):
             error_min=float_values["ERROR_MIN"],
             key=summary_key,
             value=float_values["VALUE"],
+            location_x=localization_values.get("x"),
+            location_y=localization_values.get("y"),
+            location_range=localization_values.get("range"),
             **date_dict.__dict__,
         )
 
@@ -201,12 +214,88 @@ class GeneralObservation(ObservationDate, _GeneralObservation):
         return output
 
 
-Observation = HistoryObservation | SummaryObservation | GeneralObservation
+@dataclass
+class RFTObservation:
+    name: str
+    well: str
+    date: str
+    property: str
+    value: float
+    error: float
+    north: float
+    east: float
+    tvd: float
+
+    @classmethod
+    def from_obs_dict(cls, directory: str, observation_dict: ObservationDict) -> Self:
+        well = None
+        observed_property = None
+        observed_value = None
+        error = None
+        date = None
+        north = None
+        east = None
+        tvd = None
+        for key, value in observation_dict.items():
+            match key:
+                case "type" | "name":
+                    pass
+                case "WELL":
+                    well = value
+                case "PROPERTY":
+                    observed_property = value
+                case "VALUE":
+                    observed_value = validate_float(value, key)
+                case "ERROR":
+                    error = validate_float(value, key)
+                case "DATE":
+                    date = value
+                case "NORTH":
+                    north = validate_float(value, key)
+                case "EAST":
+                    east = validate_float(value, key)
+                case "TVD":
+                    tvd = validate_float(value, key)
+                case _:
+                    raise _unknown_key_error(str(key), observation_dict["name"])
+        if well is None:
+            raise _missing_value_error(observation_dict["name"], "WELL")
+        if observed_value is None:
+            raise _missing_value_error(observation_dict["name"], "VALUE")
+        if observed_property is None:
+            raise _missing_value_error(observation_dict["name"], "PROPERTY")
+        if error is None:
+            raise _missing_value_error(observation_dict["name"], "ERROR")
+        if date is None:
+            raise _missing_value_error(observation_dict["name"], "DATE")
+        if north is None:
+            raise _missing_value_error(observation_dict["name"], "NORTH")
+        if east is None:
+            raise _missing_value_error(observation_dict["name"], "EAST")
+        if tvd is None:
+            raise _missing_value_error(observation_dict["name"], "TVD")
+        return cls(
+            observation_dict["name"],
+            well,
+            date,
+            observed_property,
+            observed_value,
+            error,
+            north,
+            east,
+            tvd,
+        )
+
+
+Observation = (
+    HistoryObservation | SummaryObservation | GeneralObservation | RFTObservation
+)
 
 _TYPE_TO_CLASS: dict[ObservationType, type[Observation]] = {
     ObservationType.HISTORY: HistoryObservation,
     ObservationType.SUMMARY: SummaryObservation,
     ObservationType.GENERAL: GeneralObservation,
+    ObservationType.RFT: RFTObservation,
 }