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

everest/config/sampler_config.py

@@ -1,103 +0,0 @@
-import logging
-from textwrap import dedent
-from typing import Any, Self
-
-from pydantic import BaseModel, ConfigDict, Field, model_validator
-
-from everest.optimizer.utils import get_ropt_plugin_manager
-from everest.strings import EVEREST
-
-
-class SamplerConfig(BaseModel):
-    backend: str | None = Field(
-        default=None,
-        description=dedent(
-            """
-            [Deprecated]
-
-            The correct backend will be inferred by the method. If several backends
-            have a method named `A`, pick a specific backend `B` by putting `B/A` in
-            the `method` field.
-            """
-        ),
-    )
-    method: str = Field(
-        default="norm",
-        description=dedent(
-            """
-            The sampling method or distribution used by the sampler backend.
-
-            The set of available methods depends on the sampler backend used. By
-            default a plugin based on `scipy.stats` is used, implementing the
-            following methods:
-
-            - From Probability Distributions:
-                - `norm`: Samples from a standard normal distribution (mean 0,
-                  standard deviation 1).
-                - `truncnorm`: Samples from a truncated normal distribution
-                  (mean 0, std. dev. 1), truncated to the range `[-1, 1]`.
-                - `uniform`: Samples from a uniform distribution in the range
-                  `[-1, 1]`.
-
-            - From Quasi-Monte Carlo Sequences:
-                - `sobol`: Uses Sobol' sequences.
-                - `halton`: Uses Halton sequences.
-                - `lhs`: Uses Latin Hypercube Sampling.
-
-                Note: QMC samples are generated in the unit hypercube `[0, 1]^d`
-                and then scaled to the hypercube `[-1, 1]^d`.
-            """
-        ),
-    )
-    options: dict[str, Any] | None = Field(
-        default=None,
-        description=dedent(
-            """
-            Specifies a dict of optional parameters for the sampler backend.
-
-            This dict of values is passed unchanged to the selected method in
-            the backend.
-            """
-        ),
-    )
-    shared: bool | None = Field(
-        default=None,
-        description=dedent(
-            """
-            Whether to share perturbations between realizations.
-            """
-        ),
-    )
-    model_config = ConfigDict(extra="forbid")
-
-    @model_validator(mode="after")
-    def validate_backend_and_method(self) -> Self:
-        if self.backend is not None:
-            message = (
-                "sampler.backend is deprecated. "
-                "The correct backend will be inferred by the method. "
-                "If several backends have a method named A, you need to pick "
-                "a specific backend B by putting B/A in sampler.method."
-            )
-            print(message)
-            logging.getLogger(EVEREST).warning(message)
-
-        # Update the default for backends that are not scipy:
-        if (
-            self.backend not in {None, "scipy"}
-            and "method" not in self.model_fields_set
-        ):
-            self.method = "default"
-
-        if self.backend is not None:
-            self.method = f"{self.backend}/{self.method}"
-
-        if (
-            get_ropt_plugin_manager().get_plugin_name("sampler", f"{self.method}")
-            is None
-        ):
-            raise ValueError(f"Sampler method '{self.method}' not found")
-
-        self.backend = None
-
-        return self

everest/simulator/__init__.py

@@ -1,88 +0,0 @@
-JOB_SUCCESS = "Finished"
-JOB_WAITING = "Waiting"
-JOB_RUNNING = "Running"
-JOB_FAILURE = "Failed"
-
-
-DEFAULT_DATA_SUMMARY_KEYS = ["YEAR", "YEARS", "TCPU", "TCPUDAY", "MONTH", "DAY"]
-
-
-DEFAULT_FIELD_SUMMARY_KEYS = [
-    "FOPR",
-    "FOPT",
-    "FOIR",
-    "FOIT",
-    "FWPR",
-    "FWPT",
-    "FWIR",
-    "FWIT",
-    "FGPR",
-    "FGPT",
-    "FGIR",
-    "FGIT",
-    "FVPR",
-    "FVPT",
-    "FVIR",
-    "FVIT",
-    "FWCT",
-    "FGOR",
-    "FOIP",
-    "FOIPL",
-    "FOIPG",
-    "FWIP",
-    "FGIP",
-    "FGIPL",
-    "FGIPG",
-    "FPR",
-    "FAQR",
-    "FAQRG",
-    "FAQT",
-    "FAQTG",
-    "FWGR",
-]
-
-
-_DEFAULT_WELL_SUMMARY_KEYS = [
-    "WOPR",
-    "WOPT",
-    "WOIR",
-    "WOIT",
-    "WWPR",
-    "WWPT",
-    "WWIR",
-    "WWIT",
-    "WGPR",
-    "WGPT",
-    "WGIR",
-    "WGIT",
-    "WVPR",
-    "WVPT",
-    "WVIR",
-    "WVIT",
-    "WWCT",
-    "WGOR",
-    "WWGR",
-    "WBHP",
-    "WTHP",
-    "WPI",
-]
-
-_EXCLUDED_TARGET_KEYS = "WGOR"
-
-_DEFAULT_WELL_TARGET_SUMMARY_KEYS = [
-    well_key + "T"
-    for well_key in _DEFAULT_WELL_SUMMARY_KEYS
-    if well_key.endswith("R") and well_key not in _EXCLUDED_TARGET_KEYS
-]
-
-DEFAULT_WELL_SUMMARY_KEYS = (
-    _DEFAULT_WELL_SUMMARY_KEYS + _DEFAULT_WELL_TARGET_SUMMARY_KEYS
-)
-
-
-__all__ = [
-    "JOB_FAILURE",
-    "JOB_RUNNING",
-    "JOB_SUCCESS",
-    "JOB_WAITING",
-]

everest/simulator/everest_to_ert.py

@@ -1,252 +0,0 @@
-import itertools
-import os
-from pathlib import Path
-from typing import Any, cast
-
-import everest
-from ert.config import (
-    EnsembleConfig,
-    ExecutableWorkflow,
-    ModelConfig,
-    WorkflowJob,
-)
-from ert.config.ert_config import (
-    _substitutions_from_dict,
-)
-from ert.config.parsing import ConfigDict, ConfigWarning, read_file
-from ert.config.parsing import ConfigKeys as ErtConfigKeys
-from ert.plugins import ErtPluginContext
-from everest.config import EverestConfig
-from everest.config.forward_model_config import SummaryResults
-from everest.config.install_job_config import InstallJobConfig
-from everest.config.simulator_config import SimulatorConfig
-from everest.strings import STORAGE_DIR
-
-
-def extract_summary_keys(ever_config: EverestConfig) -> list[str]:
-    summary_fms = [
-        fm
-        for fm in ever_config.forward_model
-        if fm.results is not None and fm.results.type == "summary"
-    ]
-
-    if not summary_fms:
-        return []
-
-    summary_fm = summary_fms[0]
-    assert summary_fm.results is not None
-
-    smry_results = cast(SummaryResults, summary_fm.results)
-
-    requested_keys: list[str] = ["*"] if smry_results.keys == "*" else smry_results.keys
-
-    data_keys = everest.simulator.DEFAULT_DATA_SUMMARY_KEYS
-    field_keys = everest.simulator.DEFAULT_FIELD_SUMMARY_KEYS
-    well_sum_keys = everest.simulator.DEFAULT_WELL_SUMMARY_KEYS
-    deprecated_user_specified_keys = (
-        [] if ever_config.export is None else ever_config.export.keywords
-    )
-
-    wells = (
-        [
-            variable.name
-            for control in ever_config.controls
-            for variable in control.variables
-            if control.type == "well_control"
-        ]
-        if ever_config.wells is None
-        else [w.name for w in ever_config.wells]
-    )
-
-    well_keys = [
-        f"{sum_key}:{wname}"
-        for (sum_key, wname) in itertools.product(well_sum_keys, wells)
-    ]
-
-    all_keys = data_keys + field_keys + well_keys + deprecated_user_specified_keys
-
-    return list(set(all_keys + requested_keys))
-
-
-def _extract_environment(
-    ever_config: EverestConfig, ert_config: dict[str, Any]
-) -> None:
-    default_runpath_file = os.path.join(ever_config.output_dir, ".res_runpath_list")
-    default_ens_path = os.path.join(ever_config.output_dir, STORAGE_DIR)
-
-    ert_config[ErtConfigKeys.ENSPATH] = default_ens_path
-    ert_config[ErtConfigKeys.RUNPATH_FILE] = default_runpath_file
-
-
-def _extract_simulator(ever_config: EverestConfig, ert_config: dict[str, Any]) -> None:
-    """
-    Extracts simulation data from ever_config and injects it into ert_config.
-    """
-
-    ever_simulation = ever_config.simulator or SimulatorConfig()
-
-    # Resubmit number (number of submission retries)
-    ert_config[ErtConfigKeys.MAX_SUBMIT] = ever_simulation.resubmit_limit + 1
-
-    # Maximum number of seconds (MAX_RUNTIME) a forward model is allowed to run
-    max_runtime = ever_simulation.max_runtime
-    if max_runtime is not None:
-        ert_config[ErtConfigKeys.MAX_RUNTIME] = max_runtime or 0
-
-    # Maximum amount of memory (REALIZATION_MEMORY) a forward model is allowed to use
-    max_memory = ever_simulation.max_memory
-    if max_memory is not None:
-        ert_config[ErtConfigKeys.REALIZATION_MEMORY] = max_memory or 0
-
-    # Number of cores reserved on queue nodes (NUM_CPU)
-    num_fm_cpu = ever_simulation.cores_per_node
-    if num_fm_cpu is not None:
-        ert_config[ErtConfigKeys.NUM_CPU] = num_fm_cpu
-
-
-def _job_to_dict(job: dict[str, Any] | InstallJobConfig) -> dict[str, Any]:
-    if isinstance(job, InstallJobConfig):
-        return job.model_dump(exclude_none=True)
-    return job
-
-
-def _extract_jobs(
-    ever_config: EverestConfig, ert_config: dict[str, Any], path: str
-) -> None:
-    ever_jobs = [_job_to_dict(j) for j in ever_config.install_jobs]
-    res_jobs = ert_config.get(ErtConfigKeys.INSTALL_JOB, [])
-    for job in ever_jobs:
-        if job.get("source") is not None:
-            source_path = os.path.join(path, job["source"])
-            new_job = (job["name"], (source_path, read_file(source_path)))
-            res_jobs.append(new_job)
-
-    ert_config[ErtConfigKeys.INSTALL_JOB] = res_jobs
-
-
-def _extract_workflow_jobs(
-    ever_config: EverestConfig, ert_config: dict[str, Any], path: str
-) -> None:
-    workflow_jobs = [_job_to_dict(j) for j in (ever_config.install_workflow_jobs or [])]
-
-    res_jobs = ert_config.get(ErtConfigKeys.LOAD_WORKFLOW_JOB, [])
-    for job in workflow_jobs:
-        if job.get("source") is not None:
-            new_job = (os.path.join(path, job["source"]), job["name"])
-            res_jobs.append(new_job)
-
-    if res_jobs:
-        ert_config[ErtConfigKeys.LOAD_WORKFLOW_JOB] = res_jobs
-
-
-def _extract_workflows(
-    ever_config: EverestConfig, ert_config: dict[str, Any], path: str
-) -> None:
-    trigger2res = {
-        "pre_simulation": "PRE_SIMULATION",
-        "post_simulation": "POST_SIMULATION",
-    }
-
-    res_workflows = ert_config.get(ErtConfigKeys.LOAD_WORKFLOW, [])
-    res_hooks = ert_config.get(ErtConfigKeys.HOOK_WORKFLOW, [])
-
-    for ever_trigger, (workflow_file, jobs) in _get_workflow_files(ever_config).items():
-        if jobs:
-            res_trigger = trigger2res[ever_trigger]
-            res_workflows.append((str(workflow_file), ever_trigger))
-            res_hooks.append((ever_trigger, res_trigger))
-
-    if res_workflows:
-        ert_config[ErtConfigKeys.LOAD_WORKFLOW] = res_workflows
-        ert_config[ErtConfigKeys.HOOK_WORKFLOW] = res_hooks
-
-
-def _extract_seed(ever_config: EverestConfig, ert_config: dict[str, Any]) -> None:
-    random_seed = ever_config.environment.random_seed
-
-    if random_seed:
-        ert_config[ErtConfigKeys.RANDOM_SEED] = random_seed
-
-
-def get_substitutions(
-    config_dict: ConfigDict, model_config: ModelConfig, runpath_file: Path, num_cpu: int
-) -> dict[str, str]:
-    substitutions = _substitutions_from_dict(config_dict)
-    substitutions["<RUNPATH_FILE>"] = str(runpath_file)
-    substitutions["<RUNPATH>"] = model_config.runpath_format_string
-    substitutions["<ECL_BASE>"] = model_config.eclbase_format_string
-    substitutions["<ECLBASE>"] = model_config.eclbase_format_string
-    substitutions["<NUM_CPU>"] = str(num_cpu)
-    return substitutions
-
-
-def get_workflow_jobs(ever_config: EverestConfig) -> dict[str, WorkflowJob]:
-    workflow_jobs: dict[str, WorkflowJob] = {}
-    for job in ever_config.install_workflow_jobs or []:
-        if job.executable is not None:
-            if job.name in workflow_jobs:
-                ConfigWarning.warn(
-                    f"Duplicate workflow job with name {job.name!r}, "
-                    f"overriding it with {job.executable!r}.",
-                    job.name,
-                )
-            executable = Path(job.executable)
-            if not executable.is_absolute():
-                executable = ever_config.config_directory / executable
-            workflow_jobs[job.name] = ExecutableWorkflow(
-                name=job.name,
-                min_args=None,
-                max_args=None,
-                arg_types=[],
-                executable=str(executable),
-            )
-    return workflow_jobs
-
-
-def get_ensemble_config(
-    config_dict: ConfigDict, everest_config: EverestConfig
-) -> EnsembleConfig:
-    ensemble_config = EnsembleConfig.from_dict(config_dict)
-
-    return ensemble_config
-
-
-def _everest_to_ert_config_dict(ever_config: EverestConfig) -> ConfigDict:
-    """
-    Takes as input an Everest configuration and converts it
-    to a corresponding ert config dict.
-    """
-    ert_config: dict[str, Any] = {}
-
-    config_dir = ever_config.config_directory
-    ert_config[ErtConfigKeys.DEFINE] = [
-        ("<CONFIG_PATH>", config_dir),
-        ("<CONFIG_FILE>", Path(ever_config.config_file).stem),
-    ]
-
-    # Extract simulator and simulation related configs
-    _extract_simulator(ever_config, ert_config)
-    _extract_environment(ever_config, ert_config)
-    _extract_jobs(ever_config, ert_config, config_dir)
-    _extract_workflow_jobs(ever_config, ert_config, config_dir)
-    _extract_workflows(ever_config, ert_config, config_dir)
-    _extract_seed(ever_config, ert_config)
-
-    return ert_config
-
-
-def everest_to_ert_config_dict(everest_config: EverestConfig) -> ConfigDict:
-    with ErtPluginContext():
-        config_dict = _everest_to_ert_config_dict(everest_config)
-    return config_dict
-
-
-def _get_workflow_files(ever_config: EverestConfig) -> dict[str, tuple[Path, str]]:
-    data_storage = (Path(ever_config.output_dir) / ".internal_data").resolve()
-    return {
-        trigger: (
-            data_storage / f"{trigger}.workflow",
-            "\n".join(getattr(ever_config.workflows, trigger, [])),
-        )
-        for trigger in ("pre_simulation", "post_simulation")
-    }