ert 20.0.0b0__py3-none-any.whl → 20.0.0b1__py3-none-any.whl

ert/cli/main.py

@@ -59,7 +59,7 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
             f"Config contains forward model step {fm_step_name} {count} time(s)",
         )
 
-    if not ert_config.observations and args.mode not in {
+    if not ert_config.observation_declarations and args.mode not in {
         ENSEMBLE_EXPERIMENT_MODE,
         TEST_RUN_MODE,
         WORKFLOW_MODE,
@@ -133,7 +133,6 @@ def run_cli(args: Namespace, runtime_plugins: ErtRuntimePlugins | None = None) -
         if args.port_range is None
         else (min(args.port_range), max(args.port_range) + 1),
         use_ipc_protocol=using_local_queuesystem,
-        prioritize_private_ip_address=ert_config.prioritize_private_ip_address,
     )
 
     if model.check_if_runpath_exists():

ert/config/_create_observation_dataframes.py

@@ -188,6 +188,7 @@ def _handle_rft_observation(
             "east": pl.Series([location[0]], dtype=pl.Float32),
             "north": pl.Series([location[1]], dtype=pl.Float32),
             "tvd": pl.Series([location[2]], dtype=pl.Float32),
+            "zone": pl.Series([rft_observation.zone], dtype=pl.String),
             "observations": pl.Series([rft_observation.value], dtype=pl.Float32),
             "std": pl.Series([rft_observation.error], dtype=pl.Float32),
             "radius": pl.Series([None], dtype=pl.Float32),

ert/config/_observations.py

@@ -329,6 +329,12 @@ class GeneralObservation(_GeneralObservation):
 
 
 class RFTObservation(BaseModel):
+    """Represents an RFT (Repeat Formation Tester) observation.
+
+    RFT observations are used to condition on pressure, saturation, or other
+    properties measured at specific well locations and times.
+    """
+
     type: Literal["rft_observation"] = "rft_observation"
     name: str
     well: str
@@ -349,6 +355,26 @@ class RFTObservation(BaseModel):
         filename: str,
         observed_property: str = "PRESSURE",
     ) -> list[Self]:
+        """Create RFT observations from a CSV file.
+
+        The CSV file must contain the following columns: WELL_NAME, DATE,
+        ERROR, NORTH, EAST, TVD, and a column for the observed property
+        (e.g., PRESSURE, SWAT). An optional ZONE column may also be present.
+
+        Args:
+            directory: Base directory for resolving relative file paths.
+            observation_dict: Dictionary containing the observation configuration.
+            filename: Path to the CSV file containing RFT observations.
+            observed_property: Property to observe (default: PRESSURE).
+
+        Returns:
+            List of RFTObservation instances created from the CSV file.
+
+        Raises:
+            ObservationConfigError: If the file is missing, inaccessible,
+                lacks required columns, or contains invalid observation values
+                (value=-1 and error=0).
+        """
         if not os.path.isabs(filename):
             filename = os.path.join(directory, filename)
         if not os.path.exists(filename):
@@ -425,6 +451,24 @@ class RFTObservation(BaseModel):
     def from_obs_dict(
         cls, directory: str, observation_dict: ObservationDict
     ) -> list[Self]:
+        """Create RFT observations from an observation dictionary.
+
+        Supports two modes:
+        1. CSV mode: Load observations from a CSV file specified by the CSV key.
+        2. Direct mode: Create a single observation from individual keys
+           (WELL, PROPERTY, VALUE, ERROR, DATE, NORTH, EAST, TVD, ZONE).
+
+        Args:
+            directory: Base directory for resolving relative file paths.
+            observation_dict: Dictionary containing the observation configuration.
+
+        Returns:
+            List of RFTObservation instances. Returns multiple observations when
+            loading from CSV, or a single observation when using direct mode.
+
+        Raises:
+            ObservationConfigError: If required keys are missing or invalid.
+        """
         csv_filename = None
         well = None
         observed_property = None

ert/config/ert_config.py

@@ -12,14 +12,13 @@ from os import path
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, ClassVar, Self, cast, overload
 
-import polars as pl
 from numpy.random import SeedSequence
-from pydantic import BaseModel, Field, PrivateAttr, model_validator
+from pydantic import BaseModel, Field, model_validator
 from pydantic import ValidationError as PydanticValidationError
 
+from ert.config._create_observation_dataframes import create_observation_dataframes
 from ert.substitutions import Substitutions
 
-from ._create_observation_dataframes import create_observation_dataframes
 from ._design_matrix_validator import DesignMatrixValidator
 from ._observations import (
     GeneralObservation,
@@ -689,7 +688,6 @@ 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)
@@ -704,7 +702,6 @@ 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)
 
@@ -714,32 +711,6 @@ class ErtConfig(BaseModel):
     config_path: str = Field(init=False, default="")
     observation_declarations: list[Observation] = Field(default_factory=list)
     zonemap: dict[int, list[str]] = Field(default_factory=dict)
-    _observations: dict[str, pl.DataFrame] | None = PrivateAttr(None)
-
-    @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=[],
-                    zonemap=self.zonemap,
-                )
-            self._observations = create_observation_dataframes(
-                self.observation_declarations,
-                cast(
-                    RFTConfig | None,
-                    self.ensemble_config.response_configs.get("rft", None),
-                ),
-            )
-        return self._observations
 
     @model_validator(mode="after")
     def set_fields(self) -> Self:
@@ -834,28 +805,6 @@ class ErtConfig(BaseModel):
 
         return self
 
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, ErtConfig):
-            return False
-
-        for attr in vars(self):
-            if attr == "observations":
-                if self.observations.keys() != other.observations.keys():
-                    return False
-
-                if not all(
-                    self.observations[k].equals(other.observations[k])
-                    for k in self.observations
-                ):
-                    return False
-
-                continue
-
-            if getattr(self, attr) != getattr(other, attr):
-                return False
-
-        return True
-
     @staticmethod
     def with_plugins(runtime_plugins: ErtRuntimePlugins) -> type[ErtConfig]:
         class ErtConfigWithPlugins(ErtConfig):
@@ -870,9 +819,6 @@ 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)
@@ -1137,7 +1083,6 @@ class ErtConfig(BaseModel):
                 runpath_config=model_config,
                 user_config_file=config_file_path,
                 observation_declarations=list(obs_configs),
-                prioritize_private_ip_address=cls.PRIORITIZE_PRIVATE_IP_ADDRESS,
                 zonemap=config_dict.get(ConfigKeys.ZONEMAP, ("", {}))[1],
             )
 
@@ -1157,12 +1102,10 @@ class ErtConfig(BaseModel):
 
             # PS:
             # This mutates the rft config and is necessary for the moment
-            cls_config._observations = create_observation_dataframes(
+            # Consider changing this pattern
+            _ = create_observation_dataframes(
                 obs_configs,
-                cast(
-                    RFTConfig | None,
-                    ensemble_config.response_configs.get("rft", None),
-                ),
+                cast(RFTConfig | None, ensemble_config.response_configs.get("rft")),
             )
         except PydanticValidationError as err:
             raise ConfigValidationError.from_pydantic(err) from err

ert/config/everest_response.py

@@ -79,8 +79,8 @@ class EverestResponse(ResponseConfig):
 class EverestConstraintsConfig(EverestResponse):
     type: Literal["everest_constraints"] = "everest_constraints"
     targets: list[float | None]
-    upper_bounds: list[float]
-    lower_bounds: list[float]
+    upper_bounds: list[float | None]
+    lower_bounds: list[float | None]
 
 
 responses_index.add_response_type(EverestConstraintsConfig)

ert/config/field.py

@@ -70,10 +70,10 @@ class Field(ParameterConfig):
     dimensionality: Literal[3] = 3
     ertbox_params: ErtboxParameters
     file_format: FieldFileFormat
-    output_transformation: str | None
-    input_transformation: str | None
-    truncation_min: float | None
-    truncation_max: float | None
+    output_transformation: str | None = None
+    input_transformation: str | None = None
+    truncation_min: float | None = None
+    truncation_max: float | None = None
     forward_init_file: str
     output_file: Path
     grid_file: str

ert/config/rft_config.py

@@ -7,7 +7,8 @@ import os
 import re
 import warnings
 from collections import defaultdict
-from typing import IO, Any, Literal, TypeAlias
+from dataclasses import dataclass
+from typing import IO, Any, Literal, TypeAlias, cast
 
 import numpy as np
 import numpy.typing as npt
@@ -25,19 +26,60 @@ from .responses_index import responses_index
 logger = logging.getLogger(__name__)
 
 
+# A Point in UTM/TVD coordinates
 Point: TypeAlias = tuple[float, float, float]
+# Index to a cell in a grid
 GridIndex: TypeAlias = tuple[int, int, int]
 ZoneName: TypeAlias = str
+WellName: TypeAlias = str
+DateString: TypeAlias = str
+RFTProperty: TypeAlias = str
+
+
+@dataclass(frozen=True)
+class _ZonedPoint:
+    """A point optionally constrained to be in a given zone."""
+
+    point: tuple[float | None, float | None, float | None] = (None, None, None)
+    zone_name: ZoneName | None = None
+
+    def has_zone(self) -> bool:
+        return self.zone_name is not None
 
 
 class RFTConfig(ResponseConfig):
+    """:term:`RFT` response from a :term:`reservoir simulator`.
+
+    RFTConfig is the configuration of responses in the <RUNPATH>/<ECLBASE>.RFT
+    file which may be generated from a reservoir simulator forward model step.
+
+    The file contains values for grid cells along a wellpath (see RFTReader for
+    details). RFTConfig will match the values against the given :term:`UTM`/:term:`TVD`
+    locations.
+
+    Parameters:
+        data_to_read: dictionary of the values that should be read from the rft file.
+        loations: list of optionally zone constrained points that the rft values should
+            be labeled with.
+        zonemap: The mapping from grid layer index to zone name.
+    """
+
     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)
+    data_to_read: dict[WellName, dict[DateString, list[RFTProperty]]] = Field(
+        default_factory=dict
+    )
     locations: list[Point | tuple[Point, ZoneName]] = Field(default_factory=list)
     zonemap: dict[int, list[ZoneName]] = Field(default_factory=dict)
 
+    @property
+    def _zoned_locations(self) -> list[_ZonedPoint]:
+        return [
+            _ZonedPoint(*p) if isinstance(p[1], ZoneName) else _ZonedPoint(p)
+            for p in self.locations
+        ]
+
     @property
     def expected_input_files(self) -> list[str]:
         base = self.input_files[0]
@@ -51,13 +93,13 @@ class RFTConfig(ResponseConfig):
 
     def _find_indices(
         self, egrid_file: str | os.PathLike[str] | IO[Any]
-    ) -> dict[GridIndex | None, set[Point | tuple[Point, ZoneName]]]:
+    ) -> dict[GridIndex | None, set[_ZonedPoint]]:
         indices = defaultdict(set)
         for a, b in zip(
             CornerpointGrid.read_egrid(egrid_file).find_cell_containing_point(
-                [loc[0] if isinstance(loc[1], str) else loc for loc in self.locations]
+                [cast(Point, loc.point) for loc in self._zoned_locations]
             ),
-            self.locations,
+            self._zoned_locations,
             strict=True,
         ):
             indices[a].add(b)
@@ -65,20 +107,20 @@ class RFTConfig(ResponseConfig):
 
     def _filter_zones(
         self,
-        indices: dict[GridIndex | None, set[Point | tuple[Point, ZoneName]]],
+        indices: dict[GridIndex | None, set[_ZonedPoint]],
         iens: int,
         iter_: int,
-    ) -> dict[GridIndex | None, set[Point]]:
+    ) -> dict[GridIndex | None, set[_ZonedPoint]]:
         for idx, locs in indices.items():
             if idx is not None:
                 for loc in list(locs):
-                    if isinstance(loc[1], str):
-                        zone = loc[1]
+                    if loc.has_zone():
+                        zone = cast(ZoneName, loc.zone_name)
                         # zonemap is 1-indexed so +1
                         if zone not in self.zonemap.get(idx[-1] + 1, []):
                             warnings.warn(
                                 PostSimulationWarning(
-                                    f"An RFT observation with location {loc[0]}, "
+                                    f"An RFT observation with location {loc.point}, "
                                     f"in iteration {iter_}, realization {iens} did "
                                     f"not match expected zone {zone}. The observation "
                                     "was deactivated",
@@ -86,12 +128,21 @@ class RFTConfig(ResponseConfig):
                                 stacklevel=2,
                             )
                             locs.remove(loc)
-        return {
-            k: {v[0] if isinstance(v[1], str) else v for v in vs}
-            for k, vs in indices.items()
-        }
+        return indices
 
     def read_from_file(self, run_path: str, iens: int, iter_: int) -> pl.DataFrame:
+        """Reads the RFT values from <RUNPATH>/<ECLBASE>.RFT
+
+        Also labels those values by which optionally zone constrained point
+        it belongs to.
+
+        The columns east, north, tvd is none when the value does not belong to
+        any point, otherwise it is the x,y,z values of that point. If the point
+        is constrained to be in a certain zone then the zone column is also populated.
+
+        Points which were constrained to be in a given zone, but were not contained
+        in that zone, is not labeled, and instead a warning is emitted.
+        """
         filename = substitute_runpath_name(self.input_files[0], iens, iter_)
         if filename.upper().endswith(".DATA"):
             # For backwards compatibility, it is
@@ -102,9 +153,9 @@ class RFTConfig(ResponseConfig):
         if grid_filename.upper().endswith(".RFT"):
             grid_filename = grid_filename[:-4]
         grid_filename += ".EGRID"
-        fetched: dict[tuple[str, datetime.date], dict[str, npt.NDArray[np.float32]]] = (
-            defaultdict(dict)
-        )
+        fetched: dict[
+            tuple[WellName, datetime.date], dict[RFTProperty, npt.NDArray[np.float32]]
+        ] = defaultdict(dict)
         indices = {}
         if self.locations:
             indices = self._filter_zones(self._find_indices(grid_filename), iens, iter_)
@@ -123,7 +174,10 @@ class RFTConfig(ResponseConfig):
                     "time": [],
                     "depth": [],
                     "values": [],
-                    "location": [],
+                    "east": [],
+                    "north": [],
+                    "tvd": [],
+                    "zone": [],
                 }
             )
 
@@ -170,7 +224,7 @@ class RFTConfig(ResponseConfig):
                                 list(
                                     indices.get(
                                         (c[0] - 1, c[1] - 1, c[2] - 1),
-                                        [(None, None, None)],
+                                        [_ZonedPoint()],
                                     )
                                 )
                                 for c in entry.connections
@@ -189,7 +243,10 @@ class RFTConfig(ResponseConfig):
                     "time": [],
                     "depth": [],
                     "values": [],
-                    "location": [],
+                    "east": [],
+                    "north": [],
+                    "tvd": [],
+                    "zone": [],
                 }
             )
 
@@ -204,18 +261,34 @@ class RFTConfig(ResponseConfig):
                             "values": [vals],
                             "location": pl.Series(
                                 [
-                                    locations.get(
-                                        (well, time), [(None, None, None)] * len(vals)
-                                    )
+                                    [
+                                        [loc.point for loc in locs]
+                                        for locs in locations.get(
+                                            (well, time),
+                                            [[_ZonedPoint()]] * len(vals),
+                                        )
+                                    ]
                                 ],
                                 dtype=pl.Array(
                                     pl.List(pl.Array(pl.Float32, 3)), len(vals)
                                 ),
                             ),
+                            "zone": pl.Series(
+                                [
+                                    [
+                                        [loc.zone_name for loc in locs]
+                                        for locs in locations.get(
+                                            (well, time),
+                                            [[_ZonedPoint()]] * len(vals),
+                                        )
+                                    ]
+                                ],
+                                dtype=pl.Array(pl.List(pl.String), len(vals)),
+                            ),
                         }
                     )
-                    .explode("depth", "values", "location")
-                    .explode("location")
+                    .explode("depth", "values", "location", "zone")
+                    .explode("location", "zone")
                     for (well, time), inner_dict in fetched.items()
                     for prop, vals in inner_dict.items()
                     if prop != "DEPTH" and len(vals) > 0
@@ -238,7 +311,7 @@ class RFTConfig(ResponseConfig):
 
     @property
     def primary_key(self) -> list[str]:
-        return ["east", "north", "tvd"]
+        return ["east", "north", "tvd", "zone"]
 
     @classmethod
     def from_config_dict(cls, config_dict: ConfigDict) -> RFTConfig | None:
@@ -260,8 +333,8 @@ class RFTConfig(ResponseConfig):
                     "step known to generate rft files"
                 )
 
-            declared_data: dict[str, dict[datetime.date, list[str]]] = defaultdict(
-                lambda: defaultdict(list)
+            declared_data: dict[WellName, dict[datetime.date, list[RFTProperty]]] = (
+                defaultdict(lambda: defaultdict(list))
             )
             for rft in rfts:
                 for expected in ["WELL", "DATE", "PROPERTIES"]:

ert/dark_storage/endpoints/experiment_server.py

@@ -317,11 +317,9 @@ class ExperimentRunner:
             simulation_future = loop.run_in_executor(
                 None,
                 lambda: run_model.start_simulations_thread(
-                    EvaluatorServerConfig(
-                        use_ipc_protocol=run_model.queue_config.queue_system
-                        == QueueSystem.LOCAL,
-                        prioritize_private_ip_address=site_plugins.prioritize_private_ip_address,
-                    )
+                    EvaluatorServerConfig()
+                    if run_model.queue_config.queue_system == QueueSystem.LOCAL
+                    else EvaluatorServerConfig(use_ipc_protocol=False)
                 ),
             )
             while True:

ert/ensemble_evaluator/config.py

@@ -27,7 +27,6 @@ class EvaluatorServerConfig:
         use_token: bool = True,
         host: str | None = None,
         use_ipc_protocol: bool = True,
-        prioritize_private_ip_address: bool = False,
     ) -> None:
         self.host: str | None = host
         self.router_port: int | None = None
@@ -51,7 +50,7 @@ class EvaluatorServerConfig:
         if use_ipc_protocol:
             self.uri = f"ipc:///tmp/socket-{uuid.uuid4().hex[:8]}"
         elif self.host is None:
-            self.host = get_ip_address(prioritize_private_ip_address)
+            self.host = get_ip_address()
 
         if use_token:
             self.server_public_key, self.server_secret_key = zmq.curve_keypair()

ert/gui/simulation/experiment_panel.py

@@ -55,15 +55,9 @@ def create_md_table(kv: dict[str, str], output: str) -> str:
 
 
 def get_simulation_thread(
-    model: Any,
-    rerun_failed_realizations: bool = False,
-    use_ipc_protocol: bool = False,
-    prioritize_private_ip_address: bool = False,
+    model: Any, rerun_failed_realizations: bool = False, use_ipc_protocol: bool = False
 ) -> ErtThread:
-    evaluator_server_config = EvaluatorServerConfig(
-        use_ipc_protocol=use_ipc_protocol,
-        prioritize_private_ip_address=prioritize_private_ip_address,
-    )
+    evaluator_server_config = EvaluatorServerConfig(use_ipc_protocol=use_ipc_protocol)
 
     def run() -> None:
         model.api.start_simulations_thread(
@@ -387,7 +381,6 @@ class ExperimentPanel(QWidget):
                 rerun_failed_realizations,
                 use_ipc_protocol=self.config.queue_config.queue_system
                 == QueueSystem.LOCAL,
-                prioritize_private_ip_address=self.config.prioritize_private_ip_address,
             )
             self._dialog.setup_event_monitoring(rerun_failed_realizations)
             simulation_thread.start()

ert/gui/tools/manage_experiments/storage_widget.py

@@ -22,8 +22,7 @@ from PyQt6.QtWidgets import (
     QWidget,
 )
 
-from ert.config import ErrorInfo, ErtConfig, RFTConfig
-from ert.config._create_observation_dataframes import create_observation_dataframes
+from ert.config import ErrorInfo, ErtConfig
 from ert.gui.ertnotifier import ErtNotifier
 from ert.gui.ertwidgets import CreateExperimentDialog, Suggestor
 from ert.storage import Ensemble, Experiment
@@ -170,26 +169,29 @@ class StorageWidget(QWidget):
         if create_experiment_dialog.exec():
             try:
                 with self._notifier.write_storage() as storage:
-                    response_configs = (
-                        self._ert_config.ensemble_config.response_configuration
+                    parameter_configuration = (
+                        self._ert_config.parameter_configurations_with_design_matrix
                     )
-
-                    rft_config = next(
-                        (r for r in response_configs if r.type == "rft"),
-                        None,
+                    response_configuration = (
+                        self._ert_config.ensemble_config.response_configuration
                     )
-                    if rft_config is not None:
-                        rft_config = cast(RFTConfig, rft_config)
-
                     ensemble = storage.create_experiment(
-                        parameters=self._ert_config.parameter_configurations_with_design_matrix,
-                        responses=response_configs,
-                        observations=create_observation_dataframes(
-                            observations=self._ert_config.observation_declarations,
-                            rft_config=rft_config,
-                        ),
+                        experiment_config={
+                            "parameter_configuration": [
+                                c.model_dump(mode="json")
+                                for c in parameter_configuration
+                            ],
+                            "response_configuration": [
+                                c.model_dump(mode="json")
+                                for c in response_configuration
+                            ],
+                            "observations": [
+                                d.model_dump(mode="json")
+                                for d in self._ert_config.observation_declarations
+                            ],
+                            "ert_templates": self._ert_config.ert_templates,
+                        },
                         name=create_experiment_dialog.experiment_name,
-                        templates=self._ert_config.ert_templates,
                     ).create_ensemble(
                         name=create_experiment_dialog.ensemble_name,
                         ensemble_size=self._ensemble_size,

ert/plugins/plugin_manager.py

@@ -338,7 +338,6 @@ class ErtRuntimePlugins(BaseModel):
     environment_variables: Mapping[str, str] = Field(default_factory=dict)
     env_pr_fm_step: Mapping[str, Mapping[str, Any]] = Field(default_factory=dict)
     help_links: dict[str, str] = Field(default_factory=dict)
-    prioritize_private_ip_address: bool = False
 
 
 def get_site_plugins(
@@ -387,9 +386,6 @@ def get_site_plugins(
         ),
         env_pr_fm_step=plugin_manager.get_forward_model_configuration(),
         help_links=plugin_manager.get_help_links(),
-        prioritize_private_ip_address=site_configurations.prioritize_private_ip_address
-        if site_configurations
-        else False,
     )
 
     return runtime_plugins

ert/run_models/ensemble_experiment.py

@@ -1,16 +1,14 @@
 from __future__ import annotations
 
 import logging
-from typing import ClassVar, cast
+from typing import ClassVar
 from uuid import UUID
 
 from pydantic import PrivateAttr
 
 from ert.config import (
-    ParameterConfig,
     PostExperimentFixtures,
     PreExperimentFixtures,
-    ResponseConfig,
 )
 from ert.ensemble_evaluator import EvaluatorServerConfig
 from ert.run_models.initial_ensemble_run_model import (
@@ -54,11 +52,8 @@ class EnsembleExperiment(InitialEnsembleRunModel, EnsembleExperimentConfig):
         self.run_workflows(fixtures=PreExperimentFixtures(random_seed=self.random_seed))
 
         experiment_storage = self._storage.create_experiment(
-            parameters=cast(list[ParameterConfig], self.parameter_configuration),
-            observations=self.observation_dataframes(),
-            responses=cast(list[ResponseConfig], self.response_configuration),
+            experiment_config=self.model_dump(mode="json"),
             name=self.experiment_name,
-            templates=self.ert_templates,
         )
 
         ensemble_storage = self._storage.create_ensemble(