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

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])),
@@ -217,4 +217,15 @@ deprecated_keywords_list = [
         ),
         check=lambda line: line[0] == "DESIGN2PARAMS",
     ),
+    DeprecationInfo(
+        keyword="FORWARD_MODEL",
+        message=(
+            "FORWARD_MODEL DESIGN_KW will be replaced with RUN_TEMPLATE. "
+            "DESIGN2PARAMS has been replaced by DESIGN_MATRIX, so the "
+            "parameters are already available for magic string replacement "
+            "with the RUN_TEMPLATE keyword. Please use this format: "
+            "'RUN_TEMPLATE my_text_file_template.txt my_text_output_file.txt'"
+        ),
+        check=lambda line: line[0] == "DESIGN_KW",
+    ),
 ]

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,

ert/config/parsing/observations_parser.py

@@ -18,6 +18,7 @@ class ObservationType(StrEnum):
     HISTORY = "HISTORY_OBSERVATION"
     SUMMARY = "SUMMARY_OBSERVATION"
     GENERAL = "GENERAL_OBSERVATION"
+    RFT = "RFT_OBSERVATION"
 
 
 ObservationDict = dict[str, Any]
@@ -92,7 +93,7 @@ def parse_observations(content: str, filename: str) -> list[ObservationDict]:
             ), ["TYPE"]:
                 message = (
                     f"Unknown observation type '{unexpected_token}', "
-                    f"expected either 'GENERAL_OBSERVATION', "
+                    f"expected either 'RFT_OBSERVATION', 'GENERAL_OBSERVATION', "
                     f"'SUMMARY_OBSERVATION' or 'HISTORY_OBSERVATION'."
                 )
             case UnexpectedToken(token=unexpected_char, expected=allowed_chars), _:
@@ -122,7 +123,10 @@ observations_parser = Lark(
     r"""
     start: observation*
     ?observation: type OBSERVATION_NAME object? ";"
-    TYPE: "HISTORY_OBSERVATION" | "SUMMARY_OBSERVATION" | "GENERAL_OBSERVATION"
+    TYPE: "HISTORY_OBSERVATION"
+      | "SUMMARY_OBSERVATION"
+      | "GENERAL_OBSERVATION"
+      | "RFT_OBSERVATION"
     type: TYPE
     ?value: object
           | STRING

ert/config/parsing/queue_system.py

@@ -23,3 +23,12 @@ class QueueSystem(StrEnum):
     @staticmethod
     def ert_config_case() -> str:
         return "upper"
+
+    @property
+    def formatted_name(self) -> str:
+        return {
+            self.LSF: "LSF",
+            self.LOCAL: "Local",
+            self.TORQUE: "Torque/OpenPBS",
+            self.SLURM: "Slurm",
+        }[self]

ert/config/queue_config.py

@@ -51,7 +51,6 @@ class QueueOptions(
     BaseModelWithContextSupport,
     validate_assignment=True,
     extra="forbid",
-    use_enum_values=True,
     validate_default=True,
 ):
     name: QueueSystem

ert/config/response_config.py

@@ -31,7 +31,6 @@ class ResponseMetadata(BaseModel):
 
 class ResponseConfig(BaseModel):
     type: str
-    name: str
     input_files: list[str] = Field(default_factory=list)
     keys: list[str] = Field(default_factory=list)
     has_finalized_keys: bool = False