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

ert/plugins/plugin_manager.py

@@ -5,25 +5,21 @@ import logging
 import warnings
 from argparse import ArgumentParser
 from collections.abc import Callable, Mapping, Sequence
-from pathlib import Path
-from types import TracebackType
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, overload
 
 import pluggy
 from pydantic import BaseModel, Field
 from typing_extensions import TypedDict
 
-from ert.base_model_context import init_context_var
 from ert.config import (
-    ForwardModelStep,
     ForwardModelStepDocumentation,
     ForwardModelStepPlugin,
     KnownQueueOptions,
     LegacyWorkflowConfigs,
     LocalQueueOptions,
+    SiteInstalledForwardModelStep,
     WorkflowConfigs,
     WorkflowJob,
-    forward_model_step_from_config_contents,
     workflow_job_from_file,
 )
 from ert.trace import add_span_processor
@@ -129,21 +125,6 @@ class ErtPluginManager(pluggy.PluginManager):
 
         return response.data
 
-    def get_ecl100_config_path(self) -> str | None:
-        return ErtPluginManager._evaluate_config_hook(
-            hook=self.hook.ecl100_config_path, config_name="ecl100"
-        )
-
-    def get_ecl300_config_path(self) -> str | None:
-        return ErtPluginManager._evaluate_config_hook(
-            hook=self.hook.ecl300_config_path, config_name="ecl300"
-        )
-
-    def get_flow_config_path(self) -> str | None:
-        return ErtPluginManager._evaluate_config_hook(
-            hook=self.hook.flow_config_path, config_name="flow"
-        )
-
     def get_forward_model_configuration(self) -> dict[str, dict[str, Any]]:
         response: list[PluginResponse[dict[str, str]]] = (
             self.hook.forward_model_configuration()
@@ -268,32 +249,9 @@ class ErtPluginManager(pluggy.PluginManager):
             return merged_dict
         return {k: v[0] for k, v in merged_dict.items()}
 
-    def get_installable_jobs(self) -> Mapping[str, str]:
-        return ErtPluginManager._merge_dicts(self.hook.installable_jobs())
-
     def _get_config_workflow_jobs(self) -> dict[str, str]:
         return ErtPluginManager._merge_dicts(self.hook.installable_workflow_jobs())
 
-    def get_documentation_for_jobs(self) -> dict[str, Any]:
-        job_docs = {
-            k: {
-                "config_file": v[0],
-                "source_package": v[1].plugin_name,
-                "source_function_name": v[1].function_name,
-            }
-            for k, v in ErtPluginManager._merge_dicts(
-                self.hook.installable_jobs(), include_plugin_data=True
-            ).items()
-        }
-        for key, value in job_docs.items():
-            value.update(
-                ErtPluginManager._evaluate_job_doc_hook(
-                    self.hook.job_documentation,
-                    key,
-                )
-            )
-        return job_docs
-
     def get_documentation_for_forward_model_steps(
         self,
     ) -> dict[str, ForwardModelStepDocumentation]:
@@ -370,7 +328,7 @@ class ErtPluginManager(pluggy.PluginManager):
 
 
 class ErtRuntimePlugins(BaseModel):
-    installed_forward_model_steps: Mapping[str, ForwardModelStep] = Field(
+    installed_forward_model_steps: Mapping[str, SiteInstalledForwardModelStep] = Field(
         default_factory=dict
     )
     installed_workflow_jobs: Mapping[str, WorkflowJob] = Field(default_factory=dict)
@@ -380,95 +338,66 @@ 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
 
 
-class ErtPluginContext:
-    def __init__(
-        self,
-        plugins: list[object] | None = None,
-        logger: logging.Logger | None = None,
-    ) -> None:
-        self.plugin_manager = ErtPluginManager(plugins=plugins)
-        self._logger = logger
-
-    def __enter__(self) -> ErtRuntimePlugins:
-        if self._logger is not None:
-            self.plugin_manager.add_logging_handle_to_root(logger=self._logger)
-        self.plugin_manager.add_span_processor_to_trace_provider()
-        logger.debug(str(self.plugin_manager))
-
-        site_configurations = self.plugin_manager.get_site_configurations()
-
-        ecl100_config_path = self.plugin_manager.get_ecl100_config_path()
-        ecl300_config_path = self.plugin_manager.get_ecl300_config_path()
-        flow_config_path = self.plugin_manager.get_flow_config_path()
-
-        config_env_vars = {}
-        if ecl100_config_path is not None:
-            config_env_vars["ECL100_SITE_CONFIG"] = ecl100_config_path
+def get_site_plugins(
+    plugin_manager: ErtPluginManager | None = None,
+) -> ErtRuntimePlugins:
+    if plugin_manager is None:
+        plugin_manager = ErtPluginManager()
 
-        if ecl300_config_path is not None:
-            config_env_vars["ECL300_SITE_CONFIG"] = ecl300_config_path
+    site_configurations = plugin_manager.get_site_configurations()
+    installable_workflow_jobs = plugin_manager.get_installable_workflow_jobs()
 
-        if flow_config_path is not None:
-            config_env_vars["FLOW_SITE_CONFIG"] = flow_config_path
+    all_forward_model_steps = (
+        dict(site_configurations.installed_forward_model_steps)
+        if site_configurations
+        else {}
+    )
 
-        installable_workflow_jobs = self.plugin_manager.get_installable_workflow_jobs()
+    all_workflow_jobs: dict[str, WorkflowJob] = dict[str, WorkflowJob](
+        plugin_manager.get_ertscript_workflows().get_workflows()
+    ) | dict[str, WorkflowJob](
+        plugin_manager.get_legacy_ertscript_workflows().get_workflows()
+    )
 
-        all_forward_model_steps = (
-            dict(site_configurations.installed_forward_model_steps)
+    for _, job_path in installable_workflow_jobs.items():
+        wf_job = workflow_job_from_file(job_path, origin="site")
+        all_workflow_jobs[wf_job.name] = wf_job
+
+    for fm_step_subclass in plugin_manager.forward_model_steps:
+        # we call without required arguments to
+        # ForwardModelStepPlugin.__init__ as
+        # we expect the subclass to override __init__
+        # and provide those arguments
+        fm_step = fm_step_subclass()  # type: ignore
+        all_forward_model_steps[fm_step.name] = fm_step
+
+    runtime_plugins = ErtRuntimePlugins(
+        installed_forward_model_steps=all_forward_model_steps,
+        installed_workflow_jobs=all_workflow_jobs,
+        queue_options=site_configurations.queue_options
+        if site_configurations
+        else None,
+        environment_variables=(
+            dict(site_configurations.environment_variables)
             if site_configurations
             else {}
-        )
+        ),
+        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,
+    )
 
-        for job_name, job_path in self.plugin_manager.get_installable_jobs().items():
-            fm_step = forward_model_step_from_config_contents(
-                Path(job_path).read_text(encoding="utf-8"), job_path, job_name
-            )
-            all_forward_model_steps[job_name] = fm_step
+    return runtime_plugins
 
-        all_workflow_jobs: dict[str, WorkflowJob] = dict[str, WorkflowJob](
-            self.plugin_manager.get_ertscript_workflows().get_workflows()
-        ) | dict[str, WorkflowJob](
-            self.plugin_manager.get_legacy_ertscript_workflows().get_workflows()
-        )
 
-        for _, job_path in installable_workflow_jobs.items():
-            wf_job = workflow_job_from_file(job_path)
-            all_workflow_jobs[wf_job.name] = wf_job
-
-        for fm_step_subclass in self.plugin_manager.forward_model_steps:
-            # we call without required arguments to
-            # ForwardModelStepPlugin.__init__ as
-            # we expect the subclass to override __init__
-            # and provide those arguments
-            fm_step = fm_step_subclass()  # type: ignore
-            all_forward_model_steps[fm_step.name] = fm_step
-
-        runtime_plugins = ErtRuntimePlugins(
-            installed_forward_model_steps=all_forward_model_steps,
-            installed_workflow_jobs=all_workflow_jobs,
-            queue_options=site_configurations.queue_options
-            if site_configurations
-            else None,
-            environment_variables=config_env_vars
-            | (
-                dict(site_configurations.environment_variables)
-                if site_configurations
-                else {}
-            ),
-            env_pr_fm_step=self.plugin_manager.get_forward_model_configuration(),
-            help_links=self.plugin_manager.get_help_links(),
-        )
-
-        self._context_token = init_context_var.set(runtime_plugins)  # type: ignore
-        return runtime_plugins
+def setup_site_logging(root_logger: logging.Logger | None = None) -> None:
+    pm = ErtPluginManager()
+    if root_logger is not None:
+        pm.add_logging_handle_to_root(logger=root_logger)
 
-    def __exit__(
-        self,
-        exception: BaseException,
-        exception_type: type[BaseException],
-        traceback: TracebackType,
-    ) -> None:
-        logger.debug("Exiting plugin context")
-        init_context_var.reset(self._context_token)
+    pm.add_span_processor_to_trace_provider()

ert/resources/forward_models/run_reservoirsimulator.py

@@ -2,17 +2,15 @@
 import datetime
 import glob
 import os
-import os.path
 import re
 import shutil
 import subprocess
 import sys
 import time
 from argparse import ArgumentParser
-from collections import namedtuple
 from pathlib import Path
 from random import random
-from typing import Literal, get_args
+from typing import Literal, NamedTuple, get_args
 
 import resfo
 
@@ -44,7 +42,13 @@ class EclError(RuntimeError):
 
 
 Simulators = Literal["flow", "eclipse", "e300"]
-EclipseResult = namedtuple("EclipseResult", "errors bugs")
+
+
+class EclipseResult(NamedTuple):
+    errors: int
+    bugs: int
+
+
 body_sub_pattern = r"(\s^\s@.+$)*"
 date_sub_pattern = r"\s+AT TIME\s+(?P<Days>\d+\.\d+)\s+DAYS\s+\((?P<Date>(.+)):\s*$"
 error_pattern_e100 = (

ert/resources/forward_models/template_render.py

@@ -19,16 +19,16 @@ def load_data(filename: str) -> dict[str, Any]:
     """
     yaml_err = ""
     json_err = ""
-    with open(filename, encoding="utf-8") as fin:
-        try:
-            return yaml.safe_load(fin)
-        except yaml.YAMLError as err:
-            yaml_err = str(err)
-
-        try:
-            return json.load(fin)
-        except yaml.YAMLError as err:
-            json_err = str(err)
+    raw_data = Path(filename).read_text(encoding="utf-8")
+    try:
+        return yaml.safe_load(raw_data)
+    except yaml.YAMLError as err:
+        yaml_err = str(err)
+
+    try:
+        return json.loads(raw_data)
+    except yaml.YAMLError as err:
+        json_err = str(err)
 
     raise OSError(
         f"{filename} is neither yaml (err_msg={yaml_err}) nor json (err_msg={json_err})"

ert/resources/shell_scripts/delete_directory.py

@@ -48,8 +48,8 @@ def delete_directory(path: str) -> None:
                     for file in files:
                         delete_file(os.path.join(root, file))
 
-                    for _dir in dirs:
-                        delete_empty_directory(os.path.join(root, _dir))
+                    for dir_ in dirs:
+                        delete_empty_directory(os.path.join(root, dir_))
 
         else:
             raise OSError(f"Entry:'{path}' is not a directory")

ert/run_models/__init__.py

@@ -1,6 +1,10 @@
-from .ensemble_experiment import EnsembleExperiment
-from .ensemble_information_filter import EnsembleInformationFilter
-from .ensemble_smoother import EnsembleSmoother
+from .ensemble_experiment import EnsembleExperiment, EnsembleExperimentConfig
+from .ensemble_information_filter import (
+    EnsembleInformationFilter,
+    EnsembleInformationFilterConfig,
+)
+from .ensemble_smoother import EnsembleSmoother, EnsembleSmootherConfig
+from .evaluate_ensemble import EvaluateEnsembleConfig
 from .event import (
     RunModelEvent,
     RunModelStatusEvent,
@@ -9,16 +13,29 @@ from .event import (
     RunModelUpdateEndEvent,
 )
 from .model_factory import create_model
-from .multiple_data_assimilation import MultipleDataAssimilation
-from .run_model import ErtRunError, RunModel, RunModelAPI, StatusEvents
-from .single_test_run import SingleTestRun
+from .multiple_data_assimilation import (
+    MultipleDataAssimilation,
+    MultipleDataAssimilationConfig,
+)
+from .run_model import (
+    ErtRunError,
+    RunModel,
+    RunModelAPI,
+    StatusEvents,
+)
+from .single_test_run import SingleTestRun, SingleTestRunConfig
 
 __all__ = [
     "EnsembleExperiment",
+    "EnsembleExperimentConfig",
     "EnsembleInformationFilter",
+    "EnsembleInformationFilterConfig",
     "EnsembleSmoother",
+    "EnsembleSmootherConfig",
     "ErtRunError",
+    "EvaluateEnsembleConfig",
     "MultipleDataAssimilation",
+    "MultipleDataAssimilationConfig",
     "RunModel",
     "RunModelAPI",
     "RunModelEvent",
@@ -27,6 +44,7 @@ __all__ = [
     "RunModelUpdateBeginEvent",
     "RunModelUpdateEndEvent",
     "SingleTestRun",
+    "SingleTestRunConfig",
     "StatusEvents",
     "create_model",
 ]

ert/run_models/_create_run_path.py

@@ -2,22 +2,30 @@ from __future__ import annotations
 
 import json
 import logging
+import math
 import os
+import time
+from collections import defaultdict
 from collections.abc import Iterable, Mapping
+from copy import deepcopy
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 import orjson
 
+from _ert.utils import file_safe_timestamp
 from ert.config import (
-    ExtParamConfig,
+    EverestControl,
     Field,
     ForwardModelStep,
     GenKwConfig,
+    ParameterCardinality,
     ParameterConfig,
     SurfaceConfig,
 )
+from ert.config.design_matrix import DESIGN_MATRIX_GROUP
+from ert.config.distribution import LogNormalSettings, LogUnifSettings
 from ert.config.ert_config import create_forward_model_json
 from ert.substitutions import Substitutions, substitute_runpath_name
 from ert.utils import log_duration
@@ -33,7 +41,7 @@ logger = logging.getLogger(__name__)
 def _backup_if_existing(path: Path) -> None:
     if not path.exists():
         return
-    timestamp = datetime.now(UTC).isoformat(timespec="seconds")
+    timestamp = file_safe_timestamp(datetime.now(UTC).isoformat(timespec="seconds"))
     new_path = path.parent / f"{path.name}_backup_{timestamp}"
     path.rename(new_path)
 
@@ -52,10 +60,17 @@ def _value_export_txt(
     with path.open("w") as f:
         for key, param_map in values.items():
             for param, value in param_map.items():
-                if isinstance(value, (int | float)):
-                    print(f"{key}:{param} {value:g}", file=f)
+                if isinstance(value, int):
+                    value_str = str(value)
+                elif isinstance(value, float):
+                    value_str = f"{value:g}"
                 else:
-                    print(f"{key}:{param} {value}", file=f)
+                    value_str = str(value)
+
+                if key == DESIGN_MATRIX_GROUP:
+                    print(f"{param} {value_str}", file=f)
+                else:
+                    print(f"{key}:{param} {value_str}", file=f)
 
 
 def _value_export_json(
@@ -69,18 +84,18 @@ def _value_export_json(
     if len(values) == 0:
         return
 
-    # Hierarchical
-    json_out: dict[str, float | dict[str, float | str]] = {
-        key: dict(param_map.items()) for key, param_map in values.items()
-    }
+    # parameter file is {param: {"value": value}}
+    json_out: dict[str, dict[str, float | str]] = {}
+    for param_map in values.values():
+        for param, value in param_map.items():
+            json_out[param] = {"value": value}
 
     # Disallow NaN from being written: ERT produces the parameters and the only
     # way for the output to be NaN is if the input is invalid or if the sampling
     # function is buggy. Either way, that would be a bug and we can report it by
     # having json throw an error.
-    json.dump(
-        json_out, path.open("w"), allow_nan=False, indent=0, separators=(", ", " : ")
-    )
+    with path.open("w") as f:
+        json.dump(json_out, f, allow_nan=False, indent=0, separators=(", ", " : "))
 
 
 def _generate_parameter_files(
@@ -90,7 +105,7 @@ def _generate_parameter_files(
     iens: int,
     fs: Ensemble,
     iteration: int,
-) -> Mapping[str, Mapping[str, float | str]]:
+) -> tuple[Mapping[str, Mapping[str, float | str]], Mapping[str, float]]:
     """
     Generate parameter files that are placed in each runtime directory for
     forward-model jobs to consume.
@@ -105,10 +120,25 @@ def _generate_parameter_files(
         fs: Ensemble from which to load parameter data
 
     Returns:
-        Returns the union of parameters returned by write_to_runpath for each
-        parameter_config.
+        Returns a tuple containing: the union of parameters returned by
+        write_to_runpath for each parameter_config, and a dict with
+        timings/durations for each parameter type.
     """
+    # preload scalar parameters for this realization
+    keys = [
+        p.name
+        for p in parameter_configs
+        if p.cardinality == ParameterCardinality.multiple_configs_per_ensemble_dataset
+    ]
+    export_timings: defaultdict[str, float] = defaultdict(float)
+    scalar_data: dict[str, float | str] = {}
+    if keys:
+        start_time = time.perf_counter()
+        df = fs.load_scalar_keys(keys=keys, realizations=iens, transformed=True)
+        scalar_data = df.to_dicts()[0]
+        export_timings["load_scalar_keys"] = time.perf_counter() - start_time
     exports: dict[str, dict[str, float | str]] = {}
+    log_exports: dict[str, dict[str, float | str]] = {}
 
     for param in parameter_configs:
         # For the first iteration we do not write the parameter
@@ -116,15 +146,42 @@ def _generate_parameter_files(
         # model has completed.
         if param.forward_init and iteration == 0:
             continue
-        export_values = param.write_to_runpath(Path(run_path), iens, fs)
+        start_time = time.perf_counter()
+        export_values: dict[str, dict[str, float | str]] | None = None
+        log_export_values: dict[str, dict[str, float | str]] | None = {}
+        if param.name in scalar_data:
+            scalar_value = scalar_data[param.name]
+            export_values = {param.group_name: {param.name: scalar_value}}
+            if isinstance(param, GenKwConfig) and isinstance(
+                param.distribution, (LogNormalSettings, LogUnifSettings)
+            ):
+                if isinstance(scalar_value, float) and scalar_value > 0:
+                    log_value = math.log10(scalar_value)
+                    log_export_values = {
+                        f"LOG10_{param.group_name}": {param.name: log_value}
+                    }
+                else:
+                    logger.warning(
+                        "Could not export the log10 value of "
+                        f"{scalar_value} as it is invalid"
+                    )
+        else:
+            export_values = param.write_to_runpath(Path(run_path), iens, fs)
         if export_values:
             for group, vals in export_values.items():
                 exports.setdefault(group, {}).update(vals)
+        if log_export_values:
+            for group, vals in log_export_values.items():
+                log_exports.setdefault(group, {}).update(vals)
+        export_timings[param.type] += time.perf_counter() - start_time
         continue
-
-    _value_export_txt(run_path, export_base_name, exports)
+    start_time = time.perf_counter()
+    _value_export_txt(run_path, export_base_name, exports | log_exports)
+    export_timings["value_export_txt"] = time.perf_counter() - start_time
+    start_time = time.perf_counter()
     _value_export_json(run_path, export_base_name, exports)
-    return exports
+    export_timings["value_export_json"] = time.perf_counter() - start_time
+    return (exports, dict(export_timings))
 
 
 def _manifest_to_json(ensemble: Ensemble, iens: int, iter_: int) -> dict[str, Any]:
@@ -133,7 +190,7 @@ def _manifest_to_json(ensemble: Ensemble, iens: int, iter_: int) -> dict[str, An
     for param_config in ensemble.experiment.parameter_configuration.values():
         assert isinstance(
             param_config,
-            ExtParamConfig | GenKwConfig | Field | SurfaceConfig,
+            EverestControl | GenKwConfig | Field | SurfaceConfig,
         )
         if param_config.forward_init and ensemble.iteration == 0:
             assert not isinstance(param_config, GenKwConfig)
@@ -145,13 +202,32 @@ def _manifest_to_json(ensemble: Ensemble, iens: int, iter_: int) -> dict[str, An
     # Add expected response files to manifest
     for response_config in ensemble.experiment.response_configuration.values():
         for input_file in response_config.expected_input_files:
-            manifest[f"{response_config.response_type}_{input_file}"] = (
-                substitute_runpath_name(input_file, iens, iter_)
+            manifest[f"{response_config.type}_{input_file}"] = substitute_runpath_name(
+                input_file, iens, iter_
             )
 
     return manifest
 
 
+def _make_param_substituter(
+    substituter: Substitutions,
+    param_data: Mapping[str, Mapping[str, str | float]],
+) -> Substitutions:
+    param_substituter = deepcopy(substituter)
+    for values in param_data.values():
+        for param_name, value in values.items():
+            if isinstance(value, int):
+                formatted_value = str(value)
+            elif isinstance(value, float):
+                formatted_value = f"{value:g}"
+            else:
+                formatted_value = str(value)
+
+            param_substituter[f"<{param_name}>"] = formatted_value
+
+    return param_substituter
+
+
 @log_duration(logger, logging.INFO)
 def create_run_path(
     run_args: list[RunArg],
@@ -168,13 +244,19 @@ def create_run_path(
     if context_env is None:
         context_env = {}
     runpaths.set_ert_ensemble(ensemble.name)
-
+    timings = {
+        "generate_parameter_files": 0.0,
+        "substitute_parameters": 0.0,
+        "substitute_real_iter": 0.0,
+        "result_file_to_target": 0.0,
+    }
     substituter = Substitutions(substitutions)
     for run_arg in run_args:
         run_path = Path(run_arg.runpath)
         if run_arg.active:
             run_path.mkdir(parents=True, exist_ok=True)
-            param_data = _generate_parameter_files(
+            start_time = time.perf_counter()
+            (param_data, detailed_parameter_timings) = _generate_parameter_files(
                 ensemble.experiment.parameter_configuration.values(),
                 parameters_file,
                 run_path,
@@ -182,22 +264,29 @@ def create_run_path(
                 ensemble,
                 ensemble.iteration,
             )
+            for parameter_type, duration in detailed_parameter_timings.items():
+                if parameter_type not in timings:
+                    timings[parameter_type] = 0.0
+                timings[parameter_type] += duration
+
+            timings["generate_parameter_files"] += time.perf_counter() - start_time
+            real_iter_substituter = substituter.real_iter_substituter(
+                run_arg.iens, ensemble.iteration
+            )
+            param_substituter = _make_param_substituter(
+                real_iter_substituter, param_data
+            )
             for (
                 source_file_content,
                 target_file,
             ) in ensemble.experiment.templates_configuration:
-                target_file = substituter.substitute_real_iter(
-                    target_file, run_arg.iens, ensemble.iteration
-                )
-                result = substituter.substitute_real_iter(
-                    source_file_content,
-                    run_arg.iens,
-                    ensemble.iteration,
-                )
-                result = substituter.substitute_parameters(
-                    result,
-                    param_data,
-                )
+                start_time = time.perf_counter()
+                target_file = real_iter_substituter.substitute(target_file)
+                timings["substitute_real_iter"] += time.perf_counter() - start_time
+                start_time = time.perf_counter()
+                result = param_substituter.substitute(source_file_content)
+                timings["substitute_parameters"] += time.perf_counter() - start_time
+                start_time = time.perf_counter()
                 target = run_path / target_file
                 if not target.parent.exists():
                     os.makedirs(
@@ -205,10 +294,13 @@ def create_run_path(
                         exist_ok=True,
                     )
                 target.write_text(result)
+                timings["result_file_to_target"] += time.perf_counter() - start_time
 
             path = run_path / "jobs.json"
+            start_time = time.perf_counter()
             _backup_if_existing(path)
-
+            timings["backup_if_existing"] = time.perf_counter() - start_time
+            start_time = time.perf_counter()
             forward_model_output = create_forward_model_json(
                 context=substitutions,
                 forward_model_steps=forward_model_steps,
@@ -225,12 +317,15 @@ def create_run_path(
                     option=orjson.OPT_NON_STR_KEYS | orjson.OPT_INDENT_2,
                 )
             )
+            timings["jobs_to_json"] = time.perf_counter() - start_time
             # Write MANIFEST file to runpath use to avoid NFS sync issues
+            start_time = time.perf_counter()
             data = _manifest_to_json(ensemble, run_arg.iens, run_arg.itr)
             Path(run_path / "manifest.json").write_bytes(
                 orjson.dumps(data, option=orjson.OPT_NON_STR_KEYS | orjson.OPT_INDENT_2)
             )
-
+            timings["manifest_to_json"] = time.perf_counter() - start_time
+    logger.info(f"_create_run_path durations: {timings}")
     runpaths.write_runpath_list(
         [ensemble.iteration], [real.iens for real in run_args if real.active]
     )