ert 19.0.1__py3-none-any.whl → 20.0.0b1__py3-none-any.whl

ert/config/parameter_config.py

@@ -126,35 +126,28 @@ class ParameterConfig(BaseModel):
     def transform_data(self) -> Callable[[float], float]:
         return lambda x: x
 
-    def sample_value(
-        self,
-        global_seed: str,
-        realization: int,
+    def sample_values(
+        self, global_seed: str, active_realizations: list[int], num_realizations: int
     ) -> npt.NDArray[np.double]:
         """
-        Generate a sample value for each key in a parameter group.
+        Generate reproducible standard-normal samples for active realizations.
 
-        The sampling is reproducible and dependent on a global seed combined
-        with the parameter group name and individual key names. The 'realization'
-        parameter determines the specific sample point from the distribution for each
-        parameter.
+        For this parameter (identified by self.group_name and self.name), a random
+        sampling of size `num_realizations` is constructed using an RNG
+        seeded from `global_seed` and the parameter name. The entries at the
+        indices specified by `active_realizations` are then returned.
 
         Parameters:
-        - global_seed (str): A global seed string used for RNG seed generation to ensure
-        reproducibility across runs.
-        - realization (int): An integer used to advance the RNG to a specific point in
-        its sequence, effectively selecting the 'realization'-th sample from the
-        distribution.
+        - global_seed (str): A global seed string used for RNG seed generation to
+        ensure reproducibility across runs.
+        - active_realizations (list[int]): indices of the realizations
+        to select from the sampling vector; each must satisfy 0 <= i < num_realizations.
+        - num_realizations (int): Total number of realizations. Assures stable sampling
+        for a given global_seed regardless of currently active realizations.
 
         Returns:
-        - npt.NDArray[np.double]: An array of sample values, one for each key in the
-        provided list.
-
-        Note:
-        The method uses SHA-256 for hash generation and numpy's default random number
-        generator for sampling. The RNG state is advanced to the 'realization' point
-        before generating a single sample, enhancing efficiency by avoiding the
-        generation of large, unused sample sets.
+        - npt.NDArray[np.double]: Array of shape (len(active_realizations),
+        containing sample values, one for each `active_realization`.
         """
         key_hash = sha256(
             global_seed.encode("utf-8") + f"{self.group_name}:{self.name}".encode()
@@ -162,9 +155,6 @@ class ParameterConfig(BaseModel):
         seed = np.frombuffer(key_hash.digest(), dtype="uint32")
         rng = np.random.default_rng(seed)
 
-        # Advance the RNG state to the realization point
-        rng.standard_normal(realization)
-
-        # Generate a single sample
-        value = rng.standard_normal(1)
-        return np.array([value[0]])
+        # Generate samples for all active realizations
+        all_values = rng.standard_normal(num_realizations)
+        return all_values[active_realizations]

ert/config/parsing/__init__.py

@@ -36,7 +36,6 @@ __all__ = [
     "ObservationConfigError",
     "ObservationDict",
     "ObservationType",
-    "ObservationType",
     "QueueSystem",
     "SchemaItemType",
     "WarningInfo",

ert/config/parsing/_parse_zonemap.py

@@ -0,0 +1,45 @@
+from .config_errors import ConfigValidationError
+
+
+def parse_zonemap(filename: str, content: str) -> dict[int, list[str]]:
+    """A zonemap is a map from a simulation grids layers to a list of zone names
+    that the k-layers belongs to.
+
+    Note that the map uses 1-indexing of layers.
+    """
+    zones_at_k_value: dict[int, list[str]] = {}
+
+    base_err_msg = "On Line {line_number} in the ZONEMAP file: "
+    for idx, line in enumerate(content.splitlines()):
+        line_number = idx + 1
+        zonemap_line = _strip_comments(line).split()
+
+        if not zonemap_line:
+            continue
+
+        if len(zonemap_line) < 2:
+            raise ConfigValidationError.with_context(
+                "Number of zonenames must be 1 or more.",
+                filename,
+            )
+        try:
+            k = int(zonemap_line[0])
+        except ValueError as err:
+            raise ConfigValidationError.with_context(
+                base_err_msg.format(line_number=line_number)
+                + f"k must be an integer, was {zonemap_line[0]}.",
+                filename,
+            ) from err
+        if k <= 0:
+            raise ConfigValidationError.with_context(
+                base_err_msg.format(line_number=line_number)
+                + "k must be at least 1. Layers are 1-indexed.",
+                filename,
+            )
+        zones_at_k_value[k] = [zone.strip() for zone in zonemap_line[1:]]
+
+    return zones_at_k_value
+
+
+def _strip_comments(line: str) -> str:
+    return line.partition("--")[0].rstrip()

ert/config/parsing/config_keywords.py

@@ -31,6 +31,7 @@ class ConfigKeys(StrEnum):
     NUM_REALIZATIONS = "NUM_REALIZATIONS"
     MIN_REALIZATIONS = "MIN_REALIZATIONS"
     OBS_CONFIG = "OBS_CONFIG"
+    ZONEMAP = "ZONEMAP"
     QUEUE_SYSTEM = "QUEUE_SYSTEM"
     QUEUE_OPTION = "QUEUE_OPTION"
     HOOK_WORKFLOW = "HOOK_WORKFLOW"

ert/config/parsing/config_schema.py

@@ -1,3 +1,4 @@
+from ._parse_zonemap import parse_zonemap
 from .config_dict import ConfigDict
 from .config_keywords import ConfigKeys
 from .config_schema_deprecations import deprecated_keywords_list
@@ -333,6 +334,7 @@ def init_user_config_schema() -> ConfigSchemaDict:
         existing_path_inline_keyword(
             ConfigKeys.OBS_CONFIG, parser=lambda f, c: parse_observations(c, f)
         ),
+        existing_path_inline_keyword(ConfigKeys.ZONEMAP, parser=parse_zonemap),
         existing_path_inline_keyword(ConfigKeys.TIME_MAP),
         single_arg_keyword(ConfigKeys.GEN_KW_EXPORT_NAME),
         history_source_keyword(),

ert/config/parsing/observations_parser.py

@@ -19,6 +19,7 @@ class ObservationType(StrEnum):
     SUMMARY = "SUMMARY_OBSERVATION"
     GENERAL = "GENERAL_OBSERVATION"
     RFT = "RFT_OBSERVATION"
+    BREAKTHROUGH = "BREAKTHROUGH_OBSERVATION"
 
 
 ObservationDict = dict[str, Any]
@@ -127,6 +128,7 @@ observations_parser = Lark(
       | "SUMMARY_OBSERVATION"
       | "GENERAL_OBSERVATION"
       | "RFT_OBSERVATION"
+      | "BREAKTHROUGH_OBSERVATION"
     type: TYPE
     ?value: object
           | STRING

ert/config/response_config.py

@@ -14,35 +14,12 @@ class InvalidResponseFile(Exception):
     """
 
 
-class ResponseMetadata(BaseModel):
-    response_type: str
-    response_key: str
-    finalized: bool
-    filter_on: dict[str, list[Any]] | None = Field(
-        default=None,
-        description="""
-    Holds information about which columns the response can be filtered on.
-    For example, for gen data, { "report_step": [0, 199, 299] } indicates
-    that we can filter the response by report step with the potential values
-    [0, 199, 299].
-    """,
-    )
-
-
 class ResponseConfig(BaseModel):
     type: str
     input_files: list[str] = Field(default_factory=list)
     keys: list[str] = Field(default_factory=list)
     has_finalized_keys: bool = False
 
-    @property
-    @abstractmethod
-    def metadata(self) -> list[ResponseMetadata]:
-        """
-        Returns metadata describing this response
-
-        """
-
     @abstractmethod
     def read_from_file(self, run_path: str, iens: int, iter_: int) -> pl.DataFrame:
         """Reads the data for the response from run_path.
@@ -76,3 +53,8 @@ class ResponseConfig(BaseModel):
     def display_column(cls, value: Any, column_name: str) -> str:
         """Formats a value to a user-friendly displayable format."""
         return str(value)
+
+    @property
+    def filter_on(self) -> dict[str, dict[str, list[int]]] | None:
+        """Optional filters for this response."""
+        return None

ert/config/rft_config.py

@@ -5,8 +5,10 @@ import fnmatch
 import logging
 import os
 import re
+import warnings
 from collections import defaultdict
-from typing import IO, Any, Literal
+from dataclasses import dataclass
+from typing import IO, Any, Literal, TypeAlias, cast
 
 import numpy as np
 import numpy.typing as npt
@@ -15,31 +17,67 @@ from pydantic import Field
 from resfo_utilities import CornerpointGrid, InvalidRFTError, RFTReader
 
 from ert.substitutions import substitute_runpath_name
+from ert.warnings import PostSimulationWarning
 
 from .parsing import ConfigDict, ConfigKeys, ConfigValidationError, ConfigWarning
-from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetadata
+from .response_config import InvalidResponseFile, ResponseConfig
 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)
-    locations: list[tuple[float, float, float]] = Field(default_factory=list)
+    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 metadata(self) -> list[ResponseMetadata]:
+    def _zoned_locations(self) -> list[_ZonedPoint]:
         return [
-            ResponseMetadata(
-                response_type=self.name,
-                response_key=response_key,
-                filter_on=None,
-                finalized=self.has_finalized_keys,
-            )
-            for response_key in self.keys
+            _ZonedPoint(*p) if isinstance(p[1], ZoneName) else _ZonedPoint(p)
+            for p in self.locations
         ]
 
     @property
@@ -55,19 +93,56 @@ class RFTConfig(ResponseConfig):
 
     def _find_indices(
         self, egrid_file: str | os.PathLike[str] | IO[Any]
-    ) -> dict[tuple[int, int, int] | None, set[tuple[float, float, float]]]:
+    ) -> dict[GridIndex | None, set[_ZonedPoint]]:
         indices = defaultdict(set)
         for a, b in zip(
             CornerpointGrid.read_egrid(egrid_file).find_cell_containing_point(
-                self.locations
+                [cast(Point, loc.point) for loc in self._zoned_locations]
             ),
-            self.locations,
+            self._zoned_locations,
             strict=True,
         ):
             indices[a].add(b)
         return indices
 
+    def _filter_zones(
+        self,
+        indices: dict[GridIndex | None, set[_ZonedPoint]],
+        iens: int,
+        iter_: int,
+    ) -> dict[GridIndex | None, set[_ZonedPoint]]:
+        for idx, locs in indices.items():
+            if idx is not None:
+                for loc in list(locs):
+                    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.point}, "
+                                    f"in iteration {iter_}, realization {iens} did "
+                                    f"not match expected zone {zone}. The observation "
+                                    "was deactivated",
+                                ),
+                                stacklevel=2,
+                            )
+                            locs.remove(loc)
+        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
@@ -78,12 +153,12 @@ 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._find_indices(grid_filename)
+            indices = self._filter_zones(self._find_indices(grid_filename), iens, iter_)
         if None in indices:
             raise InvalidResponseFile(
                 f"Did not find grid coordinate for location(s) {indices[None]}"
@@ -99,7 +174,10 @@ class RFTConfig(ResponseConfig):
                     "time": [],
                     "depth": [],
                     "values": [],
-                    "location": [],
+                    "east": [],
+                    "north": [],
+                    "tvd": [],
+                    "zone": [],
                 }
             )
 
@@ -146,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
@@ -165,7 +243,10 @@ class RFTConfig(ResponseConfig):
                     "time": [],
                     "depth": [],
                     "values": [],
-                    "location": [],
+                    "east": [],
+                    "north": [],
+                    "tvd": [],
+                    "zone": [],
                 }
             )
 
@@ -180,21 +261,37 @@ 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"
+                    if prop != "DEPTH" and len(vals) > 0
                 ]
             )
         except KeyError as err:
@@ -214,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:
@@ -236,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"]:
@@ -267,6 +364,7 @@ class RFTConfig(ResponseConfig):
                 input_files=[eclbase.replace("%d", "<IENS>")],
                 keys=keys,
                 data_to_read=data_to_read,
+                zonemap=config_dict.get(ConfigKeys.ZONEMAP, ("", {}))[1],
             )
 
         return None

ert/config/summary_config.py

@@ -11,7 +11,7 @@ from ert.substitutions import substitute_runpath_name
 from ._read_summary import read_summary
 from .parsing import ConfigDict, ConfigKeys
 from .parsing.config_errors import ConfigValidationError, ConfigWarning
-from .response_config import InvalidResponseFile, ResponseConfig, ResponseMetadata
+from .response_config import InvalidResponseFile, ResponseConfig
 from .responses_index import responses_index
 
 logger = logging.getLogger(__name__)
@@ -21,18 +21,6 @@ class SummaryConfig(ResponseConfig):
     type: Literal["summary"] = "summary"
     has_finalized_keys: bool = False
 
-    @property
-    def metadata(self) -> list[ResponseMetadata]:
-        return [
-            ResponseMetadata(
-                response_type=self.type,
-                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]

ert/config/surface_config.py

@@ -10,11 +10,6 @@ import xarray as xr
 from pydantic import field_serializer
 from surfio import IrapHeader, IrapSurface
 
-from ert.field_utils import (
-    calc_rho_for_2d_grid_layer,
-    transform_local_ellipse_angle_to_local_coords,
-    transform_positions_to_local_field_coordinates,
-)
 from ert.substitutions import substitute_runpath_name
 
 from ._str_to_bool import str_to_bool
@@ -239,55 +234,3 @@ class SurfaceConfig(ParameterConfig):
         this flattening process"""
 
         return create_flattened_cube_graph(px=self.ncol, py=self.nrow, pz=1)
-
-    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],
-    ) -> 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.
-
-        Returns:
-            Scaling values (elements of the RHO matrix) as a numpy array
-              of shape=(nx,ny,nobservations)
-
-        """
-        # Transform observation positions to local surface coordinates
-        xpos, ypos = transform_positions_to_local_field_coordinates(
-            (self.xori, self.yori), self.rotation, obs_xpos, obs_ypos
-        )
-        # Transform ellipse orientation to local surface coordinates
-        rotation_angle_of_localization_ellipse = (
-            transform_local_ellipse_angle_to_local_coords(
-                self.rotation, obs_anisotropy_angle
-            )
-        )
-
-        # Assume the coordinate system is not flipped.
-        # This means the right_handed_grid_indexing is False
-        assert self.yflip == 1
-        return calc_rho_for_2d_grid_layer(
-            self.ncol,
-            self.nrow,
-            self.xinc,
-            self.yinc,
-            xpos,
-            ypos,
-            obs_main_range,
-            obs_perp_range,
-            rotation_angle_of_localization_ellipse,
-            right_handed_grid_indexing=False,
-        )

ert/dark_storage/compute/misfits.py

@@ -1,42 +0,0 @@
-from collections.abc import Mapping
-
-import numpy as np
-import numpy.typing as npt
-import pandas as pd
-
-
-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]:
-    """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_signed_chi_squared_misfits(
-    reponses_dict: Mapping[int, pd.DataFrame],
-    observation: pd.DataFrame,
-    summary_misfits: bool = False,
-) -> pd.DataFrame:
-    """
-    Compute misfits from reponses_dict (real_id, values in dataframe)
-    and observation
-    """
-    misfits_dict = {}
-    for realization_index in reponses_dict:
-        misfits_dict[realization_index] = _calculate_signed_chi_squared_misfit(
-            observation["values"],
-            reponses_dict[realization_index]
-            .loc[:, observation.index]
-            .to_numpy()
-            .flatten(),
-            observation["errors"],
-        )
-
-    df = pd.DataFrame(data=misfits_dict, index=observation.index)
-    if summary_misfits:
-        df = pd.DataFrame([df.abs().sum(axis=0)], columns=df.columns, index=[0])
-    return df.T

ert/dark_storage/endpoints/__init__.py

@@ -1,6 +1,5 @@
 from fastapi import APIRouter
 
-from .compute.misfits import router as misfits_router
 from .ensembles import router as ensembles_router
 from .experiment_server import router as experiment_server_router
 from .experiments import router as experiments_router
@@ -15,7 +14,6 @@ router.include_router(experiments_router)
 router.include_router(ensembles_router)
 router.include_router(observations_router)
 router.include_router(updates_router)
-router.include_router(misfits_router)
 router.include_router(parameters_router)
 router.include_router(responses_router)
 router.include_router(experiment_server_router)

ert/dark_storage/endpoints/experiments.py

@@ -6,7 +6,6 @@ from fastapi import APIRouter, Body, Depends, HTTPException
 from ert.config import SurfaceConfig
 from ert.dark_storage import json_schema as js
 from ert.dark_storage.common import get_storage
-from ert.shared.storage.extraction import create_priors
 from ert.storage import Storage
 
 router = APIRouter(tags=["experiment"])
@@ -26,7 +25,6 @@ def get_experiments(
             id=experiment.id,
             name=experiment.name,
             ensemble_ids=[ens.id for ens in experiment.ensembles],
-            priors=create_priors(experiment),
             userdata={},
             parameters={
                 group: config.model_dump()
@@ -34,7 +32,7 @@ def get_experiments(
                 if not isinstance(config, SurfaceConfig)
             },
             responses={
-                response_type: [m.model_dump() for m in config.metadata]
+                response_type: config.model_dump()
                 for response_type, config in experiment.response_configuration.items()
             },
             observations=experiment.response_key_to_observation_key,
@@ -62,14 +60,13 @@ def get_experiment_by_id(
         name=experiment.name,
         id=experiment.id,
         ensemble_ids=[ens.id for ens in experiment.ensembles],
-        priors=create_priors(experiment),
         userdata={},
         parameters={
             group: config.model_dump()
             for group, config in experiment.parameter_configuration.items()
         },
         responses={
-            response_type: [m.model_dump() for m in config.metadata]
+            response_type: config.model_dump()
             for response_type, config in experiment.response_configuration.items()
         },
         observations=experiment.response_key_to_observation_key,