ert 18.0.9__py3-none-any.whl → 19.0.0__py3-none-any.whl

ert/config/ert_config.py

@@ -25,6 +25,7 @@ from ._design_matrix_validator import DesignMatrixValidator
 from ._observations import (
     HistoryObservation,
     Observation,
+    RFTObservation,
     SummaryObservation,
     make_observations,
 )
@@ -62,6 +63,7 @@ from .parsing import (
 from .parsing.observations_parser import ObservationDict
 from .queue_config import KnownQueueOptions, QueueConfig
 from .refcase import Refcase
+from .rft_config import RFTConfig
 from .workflow import Workflow
 from .workflow_fixtures import fixtures_per_hook
 from .workflow_job import (
@@ -715,6 +717,7 @@ class ErtConfig(BaseModel):
     QUEUE_OPTIONS: ClassVar[KnownQueueOptions | None] = None
     RESERVED_KEYWORDS: ClassVar[list[str]] = RESERVED_KEYWORDS
     ENV_VARS: ClassVar[dict[str, str]] = {}
+    PRIORITIZE_PRIVATE_IP_ADDRESS: ClassVar[bool] = False
 
     substitutions: dict[str, str] = Field(default_factory=dict)
     ensemble_config: EnsembleConfig = Field(default_factory=EnsembleConfig)
@@ -729,6 +732,7 @@ class ErtConfig(BaseModel):
         default_factory=lambda: defaultdict(lambda: cast(list[Workflow], []))
     )
     runpath_file: Path = Path(DEFAULT_RUNPATH_FILE)
+    prioritize_private_ip_address: bool = False
 
     ert_templates: list[tuple[str, str]] = Field(default_factory=list)
 
@@ -745,6 +749,18 @@ class ErtConfig(BaseModel):
     @property
     def observations(self) -> dict[str, pl.DataFrame]:
         if self._observations is None:
+            has_rft_observations = any(
+                isinstance(o, RFTObservation) for o in self.observation_declarations
+            )
+            if (
+                has_rft_observations
+                and "rft" not in self.ensemble_config.response_configs
+            ):
+                self.ensemble_config.response_configs["rft"] = RFTConfig(
+                    input_files=[self.runpath_config.eclbase_format_string],
+                    data_to_read={},
+                    locations=[],
+                )
             computed = create_observation_dataframes(
                 self.observation_declarations,
                 self.refcase,
@@ -752,6 +768,10 @@ class ErtConfig(BaseModel):
                     GenDataConfig | None,
                     self.ensemble_config.response_configs.get("gen_data", None),
                 ),
+                cast(
+                    RFTConfig | None,
+                    self.ensemble_config.response_configs.get("rft", None),
+                ),
                 self.time_map,
                 self.history_source,
             )
@@ -848,6 +868,9 @@ class ErtConfig(BaseModel):
             )
             ENV_VARS = dict(runtime_plugins.environment_variables)
             QUEUE_OPTIONS = runtime_plugins.queue_options
+            PRIORITIZE_PRIVATE_IP_ADDRESS = (
+                runtime_plugins.prioritize_private_ip_address
+            )
 
         ErtConfigWithPlugins.model_rebuild()
         assert issubclass(ErtConfigWithPlugins, ErtConfig)
@@ -1100,6 +1123,19 @@ class ErtConfig(BaseModel):
             user_configured_.add(key)
             env_vars[key] = substituter.substitute(val)
 
+        prioritize_private_ip_address: bool = cls.PRIORITIZE_PRIVATE_IP_ADDRESS
+        if ConfigKeys.PRIORITIZE_PRIVATE_IP_ADDRESS in config_dict:
+            user_prioritize_private_ip_address = bool(
+                config_dict[ConfigKeys.PRIORITIZE_PRIVATE_IP_ADDRESS]
+            )
+            if prioritize_private_ip_address != user_prioritize_private_ip_address:
+                logger.warning(
+                    "PRIORITIZE_PRIVATE_IP_ADDRESS was overwritten by user: "
+                    f"{prioritize_private_ip_address} -> "
+                    f"{user_prioritize_private_ip_address}"
+                )
+                prioritize_private_ip_address = user_prioritize_private_ip_address
+
         try:
             refcase = Refcase.from_config_dict(config_dict)
             cls_config = cls(
@@ -1126,11 +1162,21 @@ class ErtConfig(BaseModel):
                 time_map=time_map,
                 history_source=history_source,
                 refcase=refcase,
+                prioritize_private_ip_address=prioritize_private_ip_address,
             )
 
             # The observations are created here because create_observation_dataframes
             # will perform additonal validation which needs the context in
             # obs_configs which is stripped by pydantic
+            has_rft_observations = any(
+                isinstance(o, RFTObservation) for o in obs_configs
+            )
+            if has_rft_observations and "rft" not in ensemble_config.response_configs:
+                ensemble_config.response_configs["rft"] = RFTConfig(
+                    input_files=[eclbase],
+                    data_to_read={},
+                    locations=[],
+                )
             cls_config._observations = create_observation_dataframes(
                 obs_configs,
                 refcase,
@@ -1138,6 +1184,10 @@ class ErtConfig(BaseModel):
                     GenDataConfig | None,
                     ensemble_config.response_configs.get("gen_data", None),
                 ),
+                cast(
+                    RFTConfig | None,
+                    ensemble_config.response_configs.get("rft", None),
+                ),
                 time_map,
                 history_source,
             )

ert/config/{ext_param_config.py → everest_control.py}

@@ -17,7 +17,7 @@ from ropt.workflow import find_sampler_plugin
 
 from ert.substitutions import substitute_runpath_name
 
-from .parameter_config import ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterConfig
 
 if TYPE_CHECKING:
     import numpy.typing as npt
@@ -106,7 +106,7 @@ class SamplerConfig(BaseModel):
             # from "everest" here as per old behavior.
             # Can consider logging this as if from ERT,
             # which is valid if we store SamplerConfig as part of
-            # ExtParam configs.
+            # EverestControl configs.
             logging.getLogger("everest").warning(message)
 
         # Update the default for backends that are not scipy:
@@ -142,22 +142,14 @@ class SamplerConfig(BaseModel):
         return self
 
 
-class ExtParamConfig(ParameterConfig):
-    """Create an ExtParamConfig for @key with the given @input_keys
+class EverestControl(ParameterConfig):
+    """Create an EverestControl for @key with the given @input_keys
 
     @input_keys can be either a list of keys as strings or a dict with
     keys as strings and a list of suffixes for each key.
     If a list of strings is given, the order is preserved.
     """
 
-    @property
-    def parameter_keys(self) -> list[str]:
-        return self.input_keys
-
-    @property
-    def metadata(self) -> list[ParameterMetadata]:
-        return []
-
     type: Literal["everest_parameters"] = "everest_parameters"
     input_keys: list[str] = field(default_factory=list)
     forward_init: bool = False
@@ -179,6 +171,10 @@ class ExtParamConfig(ParameterConfig):
     # "dotdash" notation is removed for everest controls via everest config.
     input_keys_dotdash: list[str] = field(default_factory=list)
 
+    @property
+    def parameter_keys(self) -> list[str]:
+        return self.input_keys
+
     def read_from_runpath(
         self, run_path: Path, real_nr: int, iteration: int
     ) -> xr.Dataset:

ert/config/everest_response.py

@@ -25,7 +25,7 @@ class EverestResponse(ResponseConfig):
     def metadata(self) -> list[ResponseMetadata]:
         return [
             ResponseMetadata(
-                response_type=self.name,
+                response_type=self.type,
                 response_key=response_key,
                 finalized=self.has_finalized_keys,
                 filter_on=None,
@@ -76,12 +76,12 @@ class EverestResponse(ResponseConfig):
             if all(isinstance(err, FileNotFoundError) for err in errors):
                 raise FileNotFoundError(
                     "Could not find one or more files/directories while reading "
-                    f"{self.name}: {','.join([str(err) for err in errors])}"
+                    f"{self.type}: {','.join([str(err) for err in errors])}"
                 )
             else:
                 raise InvalidResponseFile(
                     "Error reading "
-                    f"{self.name}, errors: {','.join([str(err) for err in errors])}"
+                    f"{self.type}, errors: {','.join([str(err) for err in errors])}"
                 )
 
         combined = pl.concat(datasets_per_name)
@@ -90,7 +90,6 @@ class EverestResponse(ResponseConfig):
 
 class EverestConstraintsConfig(EverestResponse):
     type: Literal["everest_constraints"] = "everest_constraints"
-    name: str = "everest_constraints"
     targets: list[float | None]
     upper_bounds: list[float]
     lower_bounds: list[float]
@@ -101,7 +100,6 @@ responses_index.add_response_type(EverestConstraintsConfig)
 
 class EverestObjectivesConfig(EverestResponse):
     type: Literal["everest_objectives"] = "everest_objectives"
-    name: str = "everest_objectives"
     weights: list[float | None]
     objective_types: list[Literal["mean", "stddev"]]
 

ert/config/field.py

@@ -17,16 +17,19 @@ from ert.field_utils import (
     ErtboxParameters,
     FieldFileFormat,
     Shape,
+    calc_rho_for_2d_grid_layer,
     calculate_ertbox_parameters,
     get_shape,
     read_field,
     save_field,
+    transform_local_ellipse_angle_to_local_coords,
+    transform_positions_to_local_field_coordinates,
 )
 from ert.substitutions import substitute_runpath_name
 from ert.utils import log_duration
 
 from ._str_to_bool import str_to_bool
-from .parameter_config import ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterConfig
 from .parsing import ConfigValidationError, ConfigWarning
 
 if TYPE_CHECKING:
@@ -67,6 +70,7 @@ def create_flattened_cube_graph(px: int, py: int, pz: int) -> nx.Graph[int]:
 
 class Field(ParameterConfig):
     type: Literal["field"] = "field"
+    dimensionality: Literal[3] = 3
     ertbox_params: ErtboxParameters
     file_format: FieldFileFormat
     output_transformation: str | None
@@ -85,17 +89,6 @@ class Field(ParameterConfig):
     def parameter_keys(self) -> list[str]:
         return []
 
-    @property
-    def metadata(self) -> list[ParameterMetadata]:
-        return [
-            ParameterMetadata(
-                key=self.name,
-                transformation=self.output_transformation,
-                dimensionality=3,
-                userdata={"data_origin": "FIELD", "ertbox_params": self.ertbox_params},
-            )
-        ]
-
     @classmethod
     def from_config_list(
         cls,
@@ -277,7 +270,7 @@ class Field(ParameterConfig):
         ensemble_size = len(ds.realizations)
         da = xr.DataArray(
             [
-                np.ma.MaskedArray(data=d).compressed()  # type: ignore
+                np.ma.MaskedArray(data=d).compressed()
                 for d in ds["values"].values.reshape(ensemble_size, -1)
             ]
         )
@@ -291,7 +284,7 @@ class Field(ParameterConfig):
     def _transform_data(
         self, data_array: xr.DataArray
     ) -> np.ma.MaskedArray[Any, np.dtype[np.float32]]:
-        return np.ma.MaskedArray(  # type: ignore
+        return np.ma.MaskedArray(
             _field_truncate(
                 field_transform(
                     data_array,
@@ -325,6 +318,75 @@ class Field(ParameterConfig):
     def nz(self) -> int:
         return self.ertbox_params.nz
 
+    def calc_rho_for_2d_grid_layer(
+        self,
+        obs_xpos: npt.NDArray[np.float64],
+        obs_ypos: npt.NDArray[np.float64],
+        obs_main_range: npt.NDArray[np.float64],
+        obs_perp_range: npt.NDArray[np.float64],
+        obs_anisotropy_angle: npt.NDArray[np.float64],
+        right_handed_grid_indexing: bool = True,
+    ) -> npt.NDArray[np.float64]:
+        """Function to calculate scaling values to be used in the RHO matrix
+        for distance-based localization.
+
+        Args:
+            obs_xpos: x-coordinates in global coordinates of observations
+            obs_ypos: y-coordinates in global coordinates of observations
+            obs_main_range: Size of influence ellipse main principal direction.
+            obs_perp_range: Size of influence ellipse second principal direction.
+            obs_anisotropy_angle: Rotation angle anticlock wise of main principal
+              direction of influence ellipse relative to global coordinate
+              system's x-axis.
+            right_handed_grid_indexing: When this is True the field parameters
+              grid index order counts J-index down from ny-1 to 0.
+              If the value is False, the grid index order is to count J index
+              from 0 to ny-1. As standard for 3D field parameters,
+              the grid index order follows the right_handed grid indexing.
+
+        Returns:
+            Scaling values (elements of the RHO matrix) as a numpy array
+              of shape=(nx,ny,nobservations)
+
+        """
+        # Can only be used if ertbox coordinate system is defined
+        assert self.ertbox_params.xinc is not None, (
+            "Parameter for grid resolution must be defined"
+        )
+        assert self.ertbox_params.yinc is not None, (
+            "Parameter for grid resolution must be defined"
+        )
+        assert self.ertbox_params.origin is not None, (
+            "Parameter for grid origin must be defined"
+        )
+        assert self.ertbox_params.rotation_angle is not None, (
+            "Parameter for grid rotation must be defined"
+        )
+        # Transform positions of observations into local coordinates
+        xpos, ypos = transform_positions_to_local_field_coordinates(
+            self.ertbox_params.origin,
+            self.ertbox_params.rotation_angle,
+            obs_xpos,
+            obs_ypos,
+        )
+        # Transform localization ellipse orientation to local coordinates
+        ellipse_rotation = transform_local_ellipse_angle_to_local_coords(
+            self.ertbox_params.rotation_angle, obs_anisotropy_angle
+        )
+
+        return calc_rho_for_2d_grid_layer(
+            self.ertbox_params.nx,
+            self.ertbox_params.ny,
+            self.ertbox_params.xinc,
+            self.ertbox_params.yinc,
+            xpos,
+            ypos,
+            obs_main_range,
+            obs_perp_range,
+            ellipse_rotation,
+            right_handed_grid_indexing=right_handed_grid_indexing,
+        )
+
 
 TRANSFORM_FUNCTIONS: Final[dict[str, Callable[[Any], Any]]] = {
     "LN": np.log,

ert/config/forward_model_step.py

@@ -101,15 +101,18 @@ class ForwardModelStepDocumentation(BaseModel):
     source_function_name: str = Field(default="ert")
     description: str = Field(default="No description")
     examples: str = Field(default="No examples")
-    category: (
-        Literal[
-            "utility.file_system",
-            "simulators.reservoir",
-            "modelling.reservoir",
-            "utility.templating",
-        ]
-        | str
-    ) = Field(default="Uncategorized")
+    category: Annotated[
+        str,
+        Field(
+            default="Uncategorized",
+            examples=[
+                "utility.file_system",
+                "simulators.reservoir",
+                "modelling.reservoir",
+                "utility.templating",
+            ],
+        ),
+    ]
 
 
 class ForwardModelStep(BaseModelWithContextSupport):

ert/config/gen_data_config.py

@@ -21,7 +21,6 @@ from .responses_index import responses_index
 
 class GenDataConfig(ResponseConfig):
     type: Literal["gen_data"] = "gen_data"
-    name: str = "gen_data"
     report_steps_list: list[list[int] | None] = Field(default_factory=list)
     has_finalized_keys: bool = True
 
@@ -29,7 +28,7 @@ class GenDataConfig(ResponseConfig):
     def metadata(self) -> list[ResponseMetadata]:
         return [
             ResponseMetadata(
-                response_type=self.name,
+                response_type=self.type,
                 response_key=response_key,
                 finalized=self.has_finalized_keys,
                 filter_on={"report_step": report_steps}
@@ -198,12 +197,12 @@ class GenDataConfig(ResponseConfig):
             if all(isinstance(err, FileNotFoundError) for err in errors):
                 raise FileNotFoundError(
                     "Could not find one or more files/directories while reading "
-                    f"GEN_DATA {self.name}: {','.join([str(err) for err in errors])}"
+                    f"GEN_DATA: {','.join([str(err) for err in errors])}"
                 )
             else:
                 raise InvalidResponseFile(
                     "Error reading GEN_DATA "
-                    f"{self.name}, errors: {','.join([str(err) for err in errors])}"
+                    f"{self.type}, errors: {','.join([str(err) for err in errors])}"
                 )
 
         combined = pl.concat(datasets_per_name)

ert/config/gen_kw_config.py

@@ -15,7 +15,7 @@ from typing_extensions import TypedDict
 
 from ._str_to_bool import str_to_bool
 from .distribution import DISTRIBUTION_CLASSES, DistributionSettings, get_distribution
-from .parameter_config import ParameterCardinality, ParameterConfig, ParameterMetadata
+from .parameter_config import ParameterCardinality, ParameterConfig
 from .parsing import ConfigValidationError, ConfigWarning
 
 if TYPE_CHECKING:
@@ -53,6 +53,7 @@ class DataSource(StrEnum):
 
 class GenKwConfig(ParameterConfig):
     type: Literal["gen_kw"] = "gen_kw"
+    dimensionality: Literal[1] = 1
     distribution: DistributionSettings
     forward_init: bool = False
     update: bool = True
@@ -73,17 +74,6 @@ class GenKwConfig(ParameterConfig):
     def cardinality(self) -> ParameterCardinality:
         return ParameterCardinality.multiple_configs_per_ensemble_dataset
 
-    @property
-    def metadata(self) -> list[ParameterMetadata]:
-        return [
-            ParameterMetadata(
-                key=f"{self.group}:{self.name}",
-                transformation=self.distribution.name.upper(),
-                dimensionality=1,
-                userdata={"data_origin": "GEN_KW"},
-            )
-        ]
-
     @classmethod
     def templates_from_config(
         cls, gen_kw: list[str | dict[str, str]]

ert/config/parameter_config.py

@@ -5,7 +5,7 @@ from collections.abc import Callable, Iterator
 from enum import StrEnum, auto
 from hashlib import sha256
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Literal
+from typing import TYPE_CHECKING
 
 import networkx as nx
 import numpy as np
@@ -39,13 +39,6 @@ class ParameterCardinality(StrEnum):
     one_config_per_realization_dataset = auto()
 
 
-class ParameterMetadata(BaseModel):
-    key: str
-    transformation: str | None
-    dimensionality: Literal[1, 2, 3] = 1
-    userdata: dict[str, Any]
-
-
 class ParameterConfig(BaseModel):
     type: str
     name: str
@@ -59,14 +52,6 @@ class ParameterConfig(BaseModel):
         Returns a list of parameter keys within this parameter group
         """
 
-    @property
-    @abstractmethod
-    def metadata(self) -> list[ParameterMetadata]:
-        """
-        Returns metadata describing this parameter
-
-        """
-
     @abstractmethod
     def __len__(self) -> int:
         """Number of parameters"""

ert/config/parsing/_option_dict.py

@@ -48,13 +48,21 @@ def option_dict(option_list: Sequence[str], offset: int) -> dict[str, str]:
         if len(option_pair.split(":")) == 2:
             key, val = option_pair.split(":")
             if val and key:
+                if key in result:
+                    raise ConfigValidationError.with_context(
+                        f"Option {key} occured multiple times.", option_pair
+                    )
                 result[key] = val
             else:
                 raise ConfigValidationError.with_context(
-                    f"Invalid argument {option_pair!r}", option_pair
+                    "Option argument should be of the form 'key':'value', "
+                    f"got {option_pair!r}",
+                    option_pair,
                 )
         else:
             raise ConfigValidationError.with_context(
-                f"Invalid argument {option_pair!r}", option_pair
+                "Option argument should be of the form 'key':'value', "
+                f"got {option_pair!r}",
+                option_pair,
             )
     return result

ert/config/parsing/config_keywords.py

@@ -56,6 +56,7 @@ class ConfigKeys(StrEnum):
     REALIZATION_MEMORY = "REALIZATION_MEMORY"
     SUBMIT_SLEEP = "SUBMIT_SLEEP"
     MAX_RUNNING = "MAX_RUNNING"
+    PRIORITIZE_PRIVATE_IP_ADDRESS = "PRIORITIZE_PRIVATE_IP_ADDRESS"
 
     def __repr__(self) -> str:
         return f"{self.value!r}"

ert/config/parsing/config_schema.py

@@ -126,6 +126,13 @@ def hook_workflow_keyword() -> SchemaItem:
     )
 
 
+def prioritize_private_ip_address_keyword() -> SchemaItem:
+    return SchemaItem(
+        kw=ConfigKeys.PRIORITIZE_PRIVATE_IP_ADDRESS,
+        type_map=[SchemaItemType.BOOL],
+    )
+
+
 def set_env_keyword() -> SchemaItem:
     # You can set environment variables which will be applied to the run-time
     # environment.
@@ -349,6 +356,7 @@ def init_user_config_schema() -> ConfigSchemaDict:
         install_job_keyword(),
         install_job_directory_keyword(),
         hook_workflow_keyword(),
+        prioritize_private_ip_address_keyword(),
     ]:
         schema[item.kw] = item
         if item.kw in ConfigAliases:

ert/config/parsing/config_schema_deprecations.py

@@ -39,9 +39,9 @@ deprecated_keywords_list = [
             keyword=kw,
             message=partial(
                 lambda line, kw: f"Using {kw} with substitution strings "
-                + "that are not of the form '<KEY>' is deprecated. "
-                + f"Please change {line[0]} to "
-                + f"<{line[0].replace('<', '').replace('>', '')}>",
+                "that are not of the form '<KEY>' is deprecated. "
+                f"Please change {line[0]} to "
+                f"<{line[0].replace('<', '').replace('>', '')}>",
                 kw=kw,
             ),
             check=lambda line: not DeprecationInfo.is_angle_bracketed(str(line[0])),

ert/config/parsing/config_schema_item.py

@@ -37,25 +37,34 @@ class SchemaItem:
 
     # The minimum number of arguments
     argc_min: NonNegativeInt = 1
+
     # The maximum number of arguments: None means no upper limit
     argc_max: NonNegativeInt | None = 1
+
     # A list of types for the items. Set along with argc_minmax()
     type_map: list[SchemaItemType | EnumType | None] = Field(default_factory=list)
+
     # A list of item's which must also be set (if this item is set). (can be NULL)
     required_children: list[str] = Field(default_factory=list)
+
     # Information about the deprecation if deprecated
     deprecation_info: list[DeprecationInfo] = Field(default_factory=list)
-    # if positive, arguments after this count will be concatenated with a " " between
+
+    # If positive, arguments after this count will be concatenated with a " " between
     join_after: PositiveInt | None = None
-    # if positive, arguments after this count will be interpreted as options
+
+    # If positive, arguments after this count will be interpreted as options
     options_after: NonNegativeInt | Varies | None = None
-    # if true, will accumulate many values set for key, otherwise each entry will
+
+    # If true, will accumulate many values set for key, otherwise each entry will
     # overwrite any previous value set
     multi_occurrence: bool = False
+
     # Only applies to SchemaItemType.EXISTING_PATH_INLINE where
     # the contents is then parsed
     parser: Callable[[str, str], Any] = lambda x, y: y
     expand_envvar: bool = True
+
     # Index of tokens to do substitution from until end
     substitute_from: NonNegativeInt = 1
     required_set: bool = False

ert/config/parsing/context_values.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from json import JSONEncoder
-from typing import Any, TypeVar, no_type_check
+from typing import Any, Self, TypeVar, no_type_check
 
 from .file_context_token import FileContextToken
 
@@ -37,7 +37,7 @@ class ContextBool:
 
 
 class ContextInt(int):
-    def __new__(cls, val: int, token: FileContextToken) -> ContextInt:
+    def __new__(cls, val: int, token: FileContextToken) -> Self:
         obj = super().__new__(cls, val)
         obj.token = token
         return obj
@@ -50,7 +50,7 @@ class ContextInt(int):
 
 
 class ContextFloat(float):
-    def __new__(cls, val: float, token: FileContextToken) -> ContextFloat:
+    def __new__(cls, val: float, token: FileContextToken) -> Self:
         obj = super().__new__(cls, val)
         obj.token = token
         return obj

ert/config/parsing/file_context_token.py

@@ -12,7 +12,7 @@ class FileContextToken(Token):
 
     filename: str
 
-    def __new__(cls, token: Token, filename: str) -> FileContextToken:
+    def __new__(cls, token: Token, filename: str) -> FileContextToken:  # noqa: PYI034
         inst = super().__new__(
             cls,
             token.type,