From f8d51f262ca847bfb6cd2d4b828cdf97d5a6894f Mon Sep 17 00:00:00 2001 From: DanSava Date: Wed, 8 Nov 2023 16:01:15 +0200 Subject: [PATCH] Replace ecl with resdata --- .github/workflows/annotate_cpp.yml | 2 +- .github/workflows/build_and_test.yml | 2 +- .mypy.ini | 2 +- README.md | 8 +- ci/run_ert_ctests.sh | 2 +- pyproject.toml | 4 +- script/ecl-check | 8 +- src/clib/CMakeLists.txt | 13 +- src/clib/lib/CMakeLists.txt | 2 +- src/clib/lib/enkf/enkf_obs.cpp | 14 +-- src/clib/lib/enkf/read_summary.cpp | 71 ++++++----- src/ert/__main__.py | 2 +- src/ert/config/ensemble_config.py | 8 +- src/ert/config/ert_config.py | 2 +- src/ert/config/observations.py | 10 +- src/ert/config/summary_config.py | 4 +- src/ert/gui/about_dialog.py | 6 +- src/ert/job_queue/__init__.py | 4 +- src/ert/libres_facade.py | 6 +- .../ert/forward-models/res/script/ecl_run.py | 4 +- src/ert/substitution_list.py | 2 +- test-data/poly_template/poly_eval.py.j2 | 4 +- test-data/snake_oil/jobs/snake_oil_diff.py | 4 +- test-data/snake_oil/jobs/snake_oil_npv.py | 4 +- .../snake_oil/jobs/snake_oil_simulator.py | 112 +++++++++--------- .../snake_oil_field/jobs/snake_oil_diff.py | 4 +- .../snake_oil_field/jobs/snake_oil_npv.py | 10 +- .../jobs/snake_oil_simulator.py | 96 +++++++-------- .../snake_oil/jobs/snake_oil_diff.py | 10 +- .../snake_oil/jobs/snake_oil_npv.py | 10 +- .../snake_oil/jobs/snake_oil_simulator.py | 96 +++++++-------- tests/performance_tests/performance_utils.py | 10 +- .../config/config_dict_generator.py | 26 ++-- .../unit_tests/config/test_ensemble_config.py | 20 ++-- tests/unit_tests/config/test_observations.py | 20 ++-- .../scenarios/test_summary_response.py | 10 +- tests/unit_tests/shared/share/test_ecl_run.py | 4 +- .../shared/share/test_ecl_run_new_config.py | 4 +- .../status/test_tracking_integration.py | 10 +- .../storage/test_field_parameter.py | 16 +-- .../unit_tests/storage/test_local_ensemble.py | 4 +- .../storage/test_parameter_sample_types.py | 2 +- tests/unit_tests/test_libres_facade.py | 10 +- tests/unit_tests/test_load_forward_model.py | 18 +-- 44 files changed, 342 insertions(+), 338 deletions(-) diff --git a/.github/workflows/annotate_cpp.yml b/.github/workflows/annotate_cpp.yml index 2e5ce4fd017..b4593b441ac 100644 --- a/.github/workflows/annotate_cpp.yml +++ b/.github/workflows/annotate_cpp.yml @@ -22,7 +22,7 @@ jobs: - name: Install dependencies from PyPI run: | - python3 -m pip install "conan<2" pybind11 ecl + python3 -m pip install "conan<2" pybind11 resdata - name: Create compile commands for clib run: | diff --git a/.github/workflows/build_and_test.yml b/.github/workflows/build_and_test.yml index 9f07844f030..4ddb9eb91c5 100644 --- a/.github/workflows/build_and_test.yml +++ b/.github/workflows/build_and_test.yml @@ -44,7 +44,7 @@ jobs: - name: Install dependencies from PyPI run: | - python3 -m pip install "conan<2" pybind11 ecl + python3 -m pip install "conan<2" pybind11 resdata echo "PIP_PKGS_PATH=$(python3 -m pip show conan | grep Location | cut -d ' ' -f 2 | sed -e 's@/lib/.*site-packages$@/bin@')" >> "$GITHUB_ENV" - name: Build ert clib diff --git a/.mypy.ini b/.mypy.ini index 177141ed738..3bffd3df154 100644 --- a/.mypy.ini +++ b/.mypy.ini @@ -42,7 +42,7 @@ ignore_errors = True [mypy-cwrap.*] ignore_missing_imports = True -[mypy-ecl.*] +[mypy-resdata.*] ignore_missing_imports = True [mypy-resfo.*] diff --git a/README.md b/README.md index 430a07edf69..6ef5c95e8c4 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ $ ert --help The `ert` program is based on two different repositories: -1. [ecl](https://github.com/Equinor/ecl) which contains utilities to read and write Eclipse files. +1. [resdata](https://github.com/Equinor/resdata) which contains utilities to read and write Eclipse files. 2. ert - this repository - the actual application and all of the GUI. @@ -223,8 +223,8 @@ command `ulimit -a`. In order to increase maximum number of open files, run ### Running C++ tests -The C++ code and tests require [libecl](https://github.com/Equinor/ecl). As long -as you have `pip install ecl`'d into your Python virtualenv all should work. +The C++ code and tests require [resdata](https://github.com/Equinor/resdata). As long +as you have `pip install resdata`'d into your Python virtualenv all should work. ``` sh # Create and enable a virtualenv @@ -232,7 +232,7 @@ python3 -m venv my_virtualenv source my_virtualenv/bin/activate # Install build dependencies -pip install pybind11 conan cmake ecl +pip install pybind11 conan cmake resdata # Build ERT and tests mkdir build && cd build diff --git a/ci/run_ert_ctests.sh b/ci/run_ert_ctests.sh index 6d113b1870b..606617f7dd5 100644 --- a/ci/run_ert_ctests.sh +++ b/ci/run_ert_ctests.sh @@ -44,7 +44,7 @@ enable_environment () { setup () { /opt/rh/rh-python38/root/usr/bin/python -m venv ${ERT_SOURCE_ROOT}/venv - ${ERT_SOURCE_ROOT}/venv/bin/pip install -U pip wheel setuptools cmake pybind11 "conan<2" ecl + ${ERT_SOURCE_ROOT}/venv/bin/pip install -U pip wheel setuptools cmake pybind11 "conan<2" resdata } build_ert_clib () { diff --git a/pyproject.toml b/pyproject.toml index f629a68e175..58346b221d8 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -6,7 +6,7 @@ requires = [ "scikit-build", "cmake", "ninja", - "ecl", + "resdata", "conan<2", "pybind11>=2.10.0", # If this comes out of sync with the version installed by Conan please update the version in CMakeLists ] @@ -46,7 +46,7 @@ dependencies=[ "cwrap", "deprecation", "dnspython >= 2", - "ecl >= 2.14.1", + "resdata", "ert-storage >= 0.3.16", "fastapi < 0.100.0", "filelock", diff --git a/script/ecl-check b/script/ecl-check index e8e4c77c5fc..f74af7e00a4 100755 --- a/script/ecl-check +++ b/script/ecl-check @@ -60,7 +60,7 @@ def get_symbols(path: str, *, undefined: bool) -> Set[str]: def parse_args() -> argparse.Namespace: ap = argparse.ArgumentParser( description="""\ - Script that finds symbols used by libres that are implemented in libecl. + Script that finds symbols used by libres that are implemented in resdata. """ ) ap.add_argument( @@ -76,13 +76,13 @@ def parse_args() -> argparse.Namespace: def main() -> None: args = parse_args() - import ecl + import resdata from ert.job_queue import ResPrototype res_syms = get_symbols(ResPrototype.lib._name, undefined=True) - ecl_syms = get_symbols(ecl.EclPrototype.lib._name, undefined=False) - shared_syms = ecl_syms & res_syms + resdata_syms = get_symbols(resdata.ResdataPrototype.lib._name, undefined=False) + shared_syms = resdata_syms & res_syms sym_count = {} total = 0 diff --git a/src/clib/CMakeLists.txt b/src/clib/CMakeLists.txt index 93a6a5ca21e..3724ff07757 100644 --- a/src/clib/CMakeLists.txt +++ b/src/clib/CMakeLists.txt @@ -60,25 +60,26 @@ execute_process( list(APPEND CMAKE_PREFIX_PATH "${_tmp_dir}") # ----------------------------------------------------------------- -# Detect libecl +# Detect resdata # ----------------------------------------------------------------- execute_process( - COMMAND "${_python_executable}" -c "import ecl; print(ecl.get_include())" + COMMAND "${_python_executable}" -c + "import resdata; print(resdata.get_include())" OUTPUT_VARIABLE ECL_INCLUDE_DIRS OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ECHO STDOUT COMMAND_ERROR_IS_FATAL LAST) execute_process( COMMAND "${_python_executable}" -c - "import ecl; print(ecl.EclPrototype.lib._name)" + "import resdata; print(resdata.ResdataPrototype.lib._name)" OUTPUT_VARIABLE ECL_LIBRARY OUTPUT_STRIP_TRAILING_WHITESPACE COMMAND_ECHO STDOUT COMMAND_ERROR_IS_FATAL LAST) -add_library(ecl SHARED IMPORTED GLOBAL) -set_target_properties(ecl PROPERTIES IMPORTED_LOCATION "${ECL_LIBRARY}" - IMPORTED_NO_SONAME TRUE) +add_library(resdata SHARED IMPORTED GLOBAL) +set_target_properties(resdata PROPERTIES IMPORTED_LOCATION "${ECL_LIBRARY}" + IMPORTED_NO_SONAME TRUE) function(fix_install_names target) # CMake doesn't let us link to absolute paths on macOS. This means that diff --git a/src/clib/lib/CMakeLists.txt b/src/clib/lib/CMakeLists.txt index 6f2254ff0f4..2e299c60aea 100644 --- a/src/clib/lib/CMakeLists.txt +++ b/src/clib/lib/CMakeLists.txt @@ -42,6 +42,6 @@ file( if(BUILD_TESTS) add_library(ert SHARED $) - target_link_libraries(ert _clib pybind11::embed ecl) + target_link_libraries(ert _clib pybind11::embed resdata) fix_install_names(ert) endif() diff --git a/src/clib/lib/enkf/enkf_obs.cpp b/src/clib/lib/enkf/enkf_obs.cpp index f9b64b9804a..0f84c071e39 100644 --- a/src/clib/lib/enkf/enkf_obs.cpp +++ b/src/clib/lib/enkf/enkf_obs.cpp @@ -2,22 +2,22 @@ #include #include -#include #include #include +#include ERT_CLIB_SUBMODULE("enkf_obs", m) { using namespace py::literals; m.def("read_from_refcase", - [](Cwrap refcase, std::string local_key) { - int num_steps = ecl_sum_get_last_report_step(refcase); + [](Cwrap refcase, std::string local_key) { + int num_steps = rd_sum_get_last_report_step(refcase); std::vector valid(num_steps + 1); std::vector value(num_steps + 1); for (int tstep = 0; tstep <= num_steps; tstep++) { - if (ecl_sum_has_report_step(refcase, tstep)) { - int time_index = ecl_sum_iget_report_end(refcase, tstep); - value[tstep] = ecl_sum_get_general_var( - refcase, time_index, local_key.c_str()); + if (rd_sum_has_report_step(refcase, tstep)) { + int time_index = rd_sum_iget_report_end(refcase, tstep); + value[tstep] = rd_sum_get_general_var(refcase, time_index, + local_key.c_str()); valid[tstep] = true; } else { valid[tstep] = false; diff --git a/src/clib/lib/enkf/read_summary.cpp b/src/clib/lib/enkf/read_summary.cpp index 6bd440b0ae2..877dee3948a 100644 --- a/src/clib/lib/enkf/read_summary.cpp +++ b/src/clib/lib/enkf/read_summary.cpp @@ -1,9 +1,9 @@ #include -#include -#include #include #include #include +#include +#include #include #include #include @@ -20,11 +20,11 @@ static bool matches(const std::vector &patterns, const char *key) { } ERT_CLIB_SUBMODULE("_read_summary", m) { - m.def("read_dates", [](Cwrap summary) { + m.def("read_dates", [](Cwrap summary) { if (!PyDateTimeAPI) PyDateTime_IMPORT; - time_t_vector_type *tvec = ecl_sum_alloc_time_vector(summary, true); + time_t_vector_type *tvec = rd_sum_alloc_time_vector(summary, true); int size = time_t_vector_size(tvec); pybind11::list result(size); auto t = tm{}; @@ -52,36 +52,35 @@ ERT_CLIB_SUBMODULE("_read_summary", m) { time_t_vector_free(tvec); return result; }); - m.def("read_summary", - [](Cwrap summary, std::vector keys) { - const ecl_smspec_type *smspec = ecl_sum_get_smspec(summary); - std::vector>> - summary_vectors{}; - std::vector seen_keys{}; - for (int i = 0; i < ecl_smspec_num_nodes(smspec); i++) { - const ecl::smspec_node &smspec_node = - ecl_smspec_iget_node_w_node_index(smspec, i); - const char *key = smspec_node.get_gen_key1(); - if ((matches(keys, key)) && - !(std::find(seen_keys.begin(), seen_keys.end(), key) != - seen_keys.end())) { - seen_keys.push_back(key); - int start = ecl_sum_get_first_report_step(summary); - int end = ecl_sum_get_last_report_step(summary); - std::vector data{}; - int key_index = - ecl_sum_get_general_var_params_index(summary, key); - for (int tstep = start; tstep <= end; tstep++) { - if (ecl_sum_has_report_step(summary, tstep)) { - int time_index = - ecl_sum_iget_report_end(summary, tstep); - data.push_back( - ecl_sum_iget(summary, time_index, key_index)); - } - } - summary_vectors.emplace_back(key, data); - } - } - return summary_vectors; - }); + m.def("read_summary", [](Cwrap summary, + std::vector keys) { + const rd_smspec_type *smspec = rd_sum_get_smspec(summary); + std::vector>> + summary_vectors{}; + std::vector seen_keys{}; + for (int i = 0; i < rd_smspec_num_nodes(smspec); i++) { + const rd::smspec_node &smspec_node = + rd_smspec_iget_node_w_node_index(smspec, i); + const char *key = smspec_node.get_gen_key1(); + if ((matches(keys, key)) && + !(std::find(seen_keys.begin(), seen_keys.end(), key) != + seen_keys.end())) { + seen_keys.push_back(key); + int start = rd_sum_get_first_report_step(summary); + int end = rd_sum_get_last_report_step(summary); + std::vector data{}; + int key_index = + rd_sum_get_general_var_params_index(summary, key); + for (int tstep = start; tstep <= end; tstep++) { + if (rd_sum_has_report_step(summary, tstep)) { + int time_index = rd_sum_iget_report_end(summary, tstep); + data.push_back( + rd_sum_iget(summary, time_index, key_index)); + } + } + summary_vectors.emplace_back(key, data); + } + } + return summary_vectors; + }); } diff --git a/src/ert/__main__.py b/src/ert/__main__.py index 95bd72ac000..5ed448419ce 100755 --- a/src/ert/__main__.py +++ b/src/ert/__main__.py @@ -11,7 +11,7 @@ from uuid import UUID import yaml -from ecl import set_abort_handler +from resdata import set_abort_handler import ert.shared from ert.cli import ( diff --git a/src/ert/config/ensemble_config.py b/src/ert/config/ensemble_config.py index 0d6b7f68b7f..48a6816a35f 100644 --- a/src/ert/config/ensemble_config.py +++ b/src/ert/config/ensemble_config.py @@ -7,7 +7,7 @@ from pathlib import Path from typing import Any, Dict, List, Optional, Type, Union, no_type_check, overload -from ecl.summary import EclSum +from resdata.summary import Summary from ert.field_utils import get_shape @@ -41,7 +41,7 @@ def _get_abs_path(file: Optional[str]) -> Optional[str]: class EnsembleConfig: @staticmethod - def _load_refcase(refcase_file: Optional[str]) -> Optional[EclSum]: + def _load_refcase(refcase_file: Optional[str]) -> Optional[Summary]: if refcase_file is None: return None @@ -67,7 +67,7 @@ def _load_refcase(refcase_file: Optional[str]) -> Optional[EclSum]: "lazy_load": False, "file_options": 0, } - return EclSum(**refcase_load_args) + return Summary(**refcase_load_args) def __init__( self, @@ -77,7 +77,7 @@ def __init__( surface_list: Optional[List[SurfaceConfig]] = None, summary_config: Optional[SummaryConfig] = None, field_list: Optional[List[Field]] = None, - refcase: Optional[EclSum] = None, + refcase: Optional[Summary] = None, ) -> None: _genkw_list = [] if genkw_list is None else genkw_list _gendata_list = [] if gendata_list is None else gendata_list diff --git a/src/ert/config/ert_config.py b/src/ert/config/ert_config.py index 0051add42b6..7f284a5a9cf 100644 --- a/src/ert/config/ert_config.py +++ b/src/ert/config/ert_config.py @@ -22,7 +22,7 @@ ) import xarray as xr -from ecl.util.util import CTime +from resdata.util.util import CTime from typing_extensions import Self from ert.substitution_list import SubstitutionList diff --git a/src/ert/config/observations.py b/src/ert/config/observations.py index 5d798165d92..9f0816d9afc 100644 --- a/src/ert/config/observations.py +++ b/src/ert/config/observations.py @@ -4,8 +4,8 @@ import numpy as np import xarray as xr -from ecl.summary import EclSumVarType -from ecl.util.util import IntVector +from resdata.summary import SummaryVarType +from resdata.util.util import IntVector from ert._clib.enkf_obs import read_from_refcase @@ -114,12 +114,12 @@ def _handle_history_observation( var_type = refcase.var_type(summary_key) local_key = None if var_type in [ - EclSumVarType.ECL_SMSPEC_WELL_VAR, - EclSumVarType.ECL_SMSPEC_GROUP_VAR, + SummaryVarType.RD_SMSPEC_WELL_VAR, + SummaryVarType.RD_SMSPEC_GROUP_VAR, ]: summary_node = refcase.smspec_node(summary_key) local_key = summary_node.keyword + "H:" + summary_node.wgname - elif var_type == EclSumVarType.ECL_SMSPEC_FIELD_VAR: + elif var_type == SummaryVarType.RD_SMSPEC_FIELD_VAR: summary_node = refcase.smspec_node(summary_key) local_key = summary_node.keyword + "H" else: diff --git a/src/ert/config/summary_config.py b/src/ert/config/summary_config.py index 62b0f48ef3a..1ec0fd1baae 100644 --- a/src/ert/config/summary_config.py +++ b/src/ert/config/summary_config.py @@ -6,7 +6,7 @@ from typing import TYPE_CHECKING, Set, Union import xarray as xr -from ecl.summary import EclSum +from resdata.summary import Summary from ert._clib._read_summary import ( # pylint: disable=import-error read_dates, @@ -35,7 +35,7 @@ def __post_init__(self) -> None: def read_from_file(self, run_path: str, iens: int) -> xr.Dataset: filename = self.input_file.replace("", str(iens)) try: - summary = EclSum( + summary = Summary( f"{run_path}/{filename}", include_restart=False, lazy_load=False, diff --git a/src/ert/gui/about_dialog.py b/src/ert/gui/about_dialog.py index 9bf89497e0f..374f7c336c0 100644 --- a/src/ert/gui/about_dialog.py +++ b/src/ert/gui/about_dialog.py @@ -1,4 +1,4 @@ -import ecl +import resdata from qtpy.QtCore import QSize, Qt from qtpy.QtGui import QFont from qtpy.QtWidgets import QDialog, QHBoxLayout, QLabel, QPushButton, QVBoxLayout @@ -52,7 +52,9 @@ def createInfoLayout(): version = QLabel() version.setAlignment(Qt.AlignHCenter) - version.setText(f"Versions: ecl:{ecl.__version__} ert:{ert_gui.__version__}") + version.setText( + f"Versions: resdata:{resdata.__version__} ert:{ert_gui.__version__}" + ) info_layout.addWidget(version) info_layout.addStretch(5) diff --git a/src/ert/job_queue/__init__.py b/src/ert/job_queue/__init__.py index 1d1088df39d..e9e649789f1 100644 --- a/src/ert/job_queue/__init__.py +++ b/src/ert/job_queue/__init__.py @@ -43,7 +43,7 @@ import warnings from typing import Any -import ecl # noqa +import resdata # noqa from cwrap import Prototype # noqa @@ -82,7 +82,7 @@ def __init__(self, prototype: str, bind: bool = True) -> None: super().__init__(ResPrototype.lib, prototype, bind=bind) -from ecl.util.util import updateAbortSignals # noqa +from resdata.util.util import updateAbortSignals # noqa updateAbortSignals() diff --git a/src/ert/libres_facade.py b/src/ert/libres_facade.py index 4b8aa7185dd..00397918fe1 100644 --- a/src/ert/libres_facade.py +++ b/src/ert/libres_facade.py @@ -9,8 +9,8 @@ import numpy as np import pandas as pd from deprecation import deprecated -from ecl.grid import EclGrid from pandas import DataFrame, Series +from resdata.grid import Grid from ert.analysis import AnalysisEvent, SmootherSnapshot, smoother_update from ert.config import ( @@ -133,12 +133,12 @@ def grid_file(self) -> Optional[str]: "This can lead to inconsistencies between field and grid." ), ) # type: ignore - def grid(self) -> Optional[EclGrid]: + def grid(self) -> Optional[Grid]: path = self.grid_file if path: ext = Path(path).suffix if ext in [".EGRID", ".GRID"]: - return EclGrid.load_from_file(path) + return Grid.load_from_file(path) return None @property diff --git a/src/ert/shared/share/ert/forward-models/res/script/ecl_run.py b/src/ert/shared/share/ert/forward-models/res/script/ecl_run.py index bf167c7e289..0e6654b6691 100644 --- a/src/ert/shared/share/ert/forward-models/res/script/ecl_run.py +++ b/src/ert/shared/share/ert/forward-models/res/script/ecl_run.py @@ -10,9 +10,9 @@ from collections import namedtuple from contextlib import contextmanager, suppress -from ecl.summary import EclSum from ecl_config import EclrunConfig from packaging import version +from resdata.summary import Summary def await_process_tee(process, *out_files): @@ -386,7 +386,7 @@ def summary_block(self): time.sleep(1) try: - ecl_sum = EclSum(case) + ecl_sum = Summary(case) except (OSError, ValueError): continue diff --git a/src/ert/substitution_list.py b/src/ert/substitution_list.py index 92e05ae9be4..518cc1ad77c 100644 --- a/src/ert/substitution_list.py +++ b/src/ert/substitution_list.py @@ -5,7 +5,7 @@ import re from typing import TYPE_CHECKING, Optional, Tuple, no_type_check -from ecl.ecl_util import get_num_cpu as get_num_cpu_from_data_file +from resdata.rd_util import get_num_cpu as get_num_cpu_from_data_file logger = logging.getLogger(__name__) _PATTERN = re.compile("<[^<>]+>") diff --git a/test-data/poly_template/poly_eval.py.j2 b/test-data/poly_template/poly_eval.py.j2 index be60385cec5..6b74851b323 100755 --- a/test-data/poly_template/poly_eval.py.j2 +++ b/test-data/poly_template/poly_eval.py.j2 @@ -6,7 +6,7 @@ import os import resfo import numpy as np -from ecl.summary import EclSum +from resdata.summary import Summary def _load_coeffs(filename): @@ -68,7 +68,7 @@ def make_summary(count, x_size, coeffs, update_steps): ) else: - ecl_sum = EclSum.writer( + ecl_sum = Summary.writer( "summary/POLY_SUMMARY", datetime.datetime(2010, 1, 1), 10, 10, 10 ) for s in range(count): diff --git a/test-data/snake_oil/jobs/snake_oil_diff.py b/test-data/snake_oil/jobs/snake_oil_diff.py index bd109eaba4b..fabd8ffded5 100755 --- a/test-data/snake_oil/jobs/snake_oil_diff.py +++ b/test-data/snake_oil/jobs/snake_oil_diff.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -from ecl.summary import EclSum +from resdata.summary import Summary def writeDiff(filename, vector1, vector2): @@ -9,7 +9,7 @@ def writeDiff(filename, vector1, vector2): if __name__ == "__main__": - ecl_sum = EclSum("SNAKE_OIL_FIELD") + ecl_sum = Summary("SNAKE_OIL_FIELD") report_step = 199 writeDiff( diff --git a/test-data/snake_oil/jobs/snake_oil_npv.py b/test-data/snake_oil/jobs/snake_oil_npv.py index 263f4903bda..514c20adac1 100755 --- a/test-data/snake_oil/jobs/snake_oil_npv.py +++ b/test-data/snake_oil/jobs/snake_oil_npv.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -from ecl.summary import EclSum +from resdata.summary import Summary OIL_PRICES = { "2010-01-01": 78.33, @@ -74,7 +74,7 @@ } if __name__ == "__main__": - ecl_sum = EclSum("SNAKE_OIL_FIELD") + ecl_sum = Summary("SNAKE_OIL_FIELD") start_time = ecl_sum.getStartTime() date_ranges = ecl_sum.timeRange(start_time, interval="1M") production_sums = ecl_sum.blockedProduction("FOPT", date_ranges) diff --git a/test-data/snake_oil/jobs/snake_oil_simulator.py b/test-data/snake_oil/jobs/snake_oil_simulator.py index b202785a835..144fdfc74c0 100755 --- a/test-data/snake_oil/jobs/snake_oil_simulator.py +++ b/test-data/snake_oil/jobs/snake_oil_simulator.py @@ -1,8 +1,8 @@ #!/usr/bin/env python from datetime import datetime -from ecl.summary import EclSum from oil_reservoir_synthesizer import OilSimulator +from resdata.summary import Summary def globalIndex(i, j, k, nx=10, ny=10, nz=10): @@ -19,59 +19,59 @@ def readParameters(filename): return params -def runSimulator(simulator, history_simulator, time_step_count) -> EclSum: - ecl_sum = EclSum.writer("SNAKE_OIL_FIELD", datetime(2010, 1, 1), 10, 10, 10) - - ecl_sum.addVariable("FOPT", unit="SM3") - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - ecl_sum.addVariable("FGPT", unit="SM3") - ecl_sum.addVariable("FGPR", unit="SM3/DAY") - ecl_sum.addVariable("FWPT", unit="SM3") - ecl_sum.addVariable("FWPR", unit="SM3/DAY") - ecl_sum.addVariable("FGOR", unit="SM3/SM3") - ecl_sum.addVariable("FWCT", unit="SM3/SM3") - - ecl_sum.addVariable("FOIP", unit="SM3") - ecl_sum.addVariable("FGIP", unit="SM3") - ecl_sum.addVariable("FWIP", unit="SM3") - - ecl_sum.addVariable("FOPTH", unit="SM3") - ecl_sum.addVariable("FOPRH", unit="SM3/DAY") - ecl_sum.addVariable("FGPTH", unit="SM3") - ecl_sum.addVariable("FGPRH", unit="SM3/DAY") - ecl_sum.addVariable("FWPTH", unit="SM3") - ecl_sum.addVariable("FWPRH", unit="SM3/DAY") - ecl_sum.addVariable("FGORH", unit="SM3/SM3") - ecl_sum.addVariable("FWCTH", unit="SM3/SM3") - - ecl_sum.addVariable("FOIPH", unit="SM3") - ecl_sum.addVariable("FGIPH", unit="SM3") - ecl_sum.addVariable("FWIPH", unit="SM3") - - ecl_sum.addVariable("WOPR", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WOPR", wgname="OP2", unit="SM3/DAY") - ecl_sum.addVariable("WWPR", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WWPR", wgname="OP2", unit="SM3/DAY") - ecl_sum.addVariable("WGPR", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WGPR", wgname="OP2", unit="SM3/DAY") - ecl_sum.addVariable("WGOR", wgname="OP1", unit="SM3/SM3") - ecl_sum.addVariable("WGOR", wgname="OP2", unit="SM3/SM3") - ecl_sum.addVariable("WWCT", wgname="OP1", unit="SM3/SM3") - ecl_sum.addVariable("WWCT", wgname="OP2", unit="SM3/SM3") - - ecl_sum.addVariable("WOPRH", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WOPRH", wgname="OP2", unit="SM3/DAY") - ecl_sum.addVariable("WWPRH", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WWPRH", wgname="OP2", unit="SM3/DAY") - ecl_sum.addVariable("WGPRH", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WGPRH", wgname="OP2", unit="SM3/DAY") - ecl_sum.addVariable("WGORH", wgname="OP1", unit="SM3/SM3") - ecl_sum.addVariable("WGORH", wgname="OP2", unit="SM3/SM3") - ecl_sum.addVariable("WWCTH", wgname="OP1", unit="SM3/SM3") - ecl_sum.addVariable("WWCTH", wgname="OP2", unit="SM3/SM3") - - ecl_sum.addVariable("BPR", num=globalIndex(5, 5, 5), unit="BARSA") - ecl_sum.addVariable("BPR", num=globalIndex(1, 3, 8), unit="BARSA") +def runSimulator(simulator, history_simulator, time_step_count) -> Summary: + summary = Summary.writer("SNAKE_OIL_FIELD", datetime(2010, 1, 1), 10, 10, 10) + + summary.add_variable("FOPT", unit="SM3") + summary.add_variable("FOPR", unit="SM3/DAY") + summary.add_variable("FGPT", unit="SM3") + summary.add_variable("FGPR", unit="SM3/DAY") + summary.add_variable("FWPT", unit="SM3") + summary.add_variable("FWPR", unit="SM3/DAY") + summary.add_variable("FGOR", unit="SM3/SM3") + summary.add_variable("FWCT", unit="SM3/SM3") + + summary.add_variable("FOIP", unit="SM3") + summary.add_variable("FGIP", unit="SM3") + summary.add_variable("FWIP", unit="SM3") + + summary.add_variable("FOPTH", unit="SM3") + summary.add_variable("FOPRH", unit="SM3/DAY") + summary.add_variable("FGPTH", unit="SM3") + summary.add_variable("FGPRH", unit="SM3/DAY") + summary.add_variable("FWPTH", unit="SM3") + summary.add_variable("FWPRH", unit="SM3/DAY") + summary.add_variable("FGORH", unit="SM3/SM3") + summary.add_variable("FWCTH", unit="SM3/SM3") + + summary.add_variable("FOIPH", unit="SM3") + summary.add_variable("FGIPH", unit="SM3") + summary.add_variable("FWIPH", unit="SM3") + + summary.add_variable("WOPR", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WOPR", wgname="OP2", unit="SM3/DAY") + summary.add_variable("WWPR", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WWPR", wgname="OP2", unit="SM3/DAY") + summary.add_variable("WGPR", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WGPR", wgname="OP2", unit="SM3/DAY") + summary.add_variable("WGOR", wgname="OP1", unit="SM3/SM3") + summary.add_variable("WGOR", wgname="OP2", unit="SM3/SM3") + summary.add_variable("WWCT", wgname="OP1", unit="SM3/SM3") + summary.add_variable("WWCT", wgname="OP2", unit="SM3/SM3") + + summary.add_variable("WOPRH", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WOPRH", wgname="OP2", unit="SM3/DAY") + summary.add_variable("WWPRH", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WWPRH", wgname="OP2", unit="SM3/DAY") + summary.add_variable("WGPRH", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WGPRH", wgname="OP2", unit="SM3/DAY") + summary.add_variable("WGORH", wgname="OP1", unit="SM3/SM3") + summary.add_variable("WGORH", wgname="OP2", unit="SM3/SM3") + summary.add_variable("WWCTH", wgname="OP1", unit="SM3/SM3") + summary.add_variable("WWCTH", wgname="OP2", unit="SM3/SM3") + + summary.add_variable("BPR", num=globalIndex(5, 5, 5), unit="BARSA") + summary.add_variable("BPR", num=globalIndex(1, 3, 8), unit="BARSA") time_map = [] mini_step_count = 10 @@ -79,7 +79,7 @@ def runSimulator(simulator, history_simulator, time_step_count) -> EclSum: for report_step in range(time_step_count): for mini_step in range(mini_step_count): - t_step = ecl_sum.addTStep( + t_step = summary.addTStep( report_step + 1, sim_days=report_step * mini_step_count + mini_step ) @@ -147,7 +147,7 @@ def runSimulator(simulator, history_simulator, time_step_count) -> EclSum: t_step["WWCTH:OP2"] = history_simulator.wct("OP2") print(f"RESTART REPORT {report_step+1} written at {time_map[-1]}") - return ecl_sum, time_map + return summary, time_map def roundedInt(value): diff --git a/test-data/snake_oil_field/jobs/snake_oil_diff.py b/test-data/snake_oil_field/jobs/snake_oil_diff.py index 74fdb62a6ed..f24f308af20 100755 --- a/test-data/snake_oil_field/jobs/snake_oil_diff.py +++ b/test-data/snake_oil_field/jobs/snake_oil_diff.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -from ecl.summary import EclSum +from resdata.summary import Summary def writeDiff(filename, vector1, vector2): @@ -9,7 +9,7 @@ def writeDiff(filename, vector1, vector2): if __name__ == "__main__": - ecl_sum = EclSum("SNAKE_OIL_FIELD") + ecl_sum = Summary("SNAKE_OIL_FIELD") report_step = 199 writeDiff( diff --git a/test-data/snake_oil_field/jobs/snake_oil_npv.py b/test-data/snake_oil_field/jobs/snake_oil_npv.py index 263f4903bda..bbb3ab49065 100755 --- a/test-data/snake_oil_field/jobs/snake_oil_npv.py +++ b/test-data/snake_oil_field/jobs/snake_oil_npv.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -from ecl.summary import EclSum +from resdata.summary import Summary OIL_PRICES = { "2010-01-01": 78.33, @@ -74,10 +74,10 @@ } if __name__ == "__main__": - ecl_sum = EclSum("SNAKE_OIL_FIELD") - start_time = ecl_sum.getStartTime() - date_ranges = ecl_sum.timeRange(start_time, interval="1M") - production_sums = ecl_sum.blockedProduction("FOPT", date_ranges) + summary = Summary("SNAKE_OIL_FIELD") + start_time = summary.get_start_time() + date_ranges = summary.time_range(start_time, interval="1M") + production_sums = summary.blocked_production("FOPT", date_ranges) npv = 0.0 for index in range(0, len(date_ranges) - 1): diff --git a/test-data/snake_oil_field/jobs/snake_oil_simulator.py b/test-data/snake_oil_field/jobs/snake_oil_simulator.py index 65bd4e706da..098ea37468e 100755 --- a/test-data/snake_oil_field/jobs/snake_oil_simulator.py +++ b/test-data/snake_oil_field/jobs/snake_oil_simulator.py @@ -1,8 +1,8 @@ #!/usr/bin/env python from datetime import datetime -from ecl.summary import EclSum from oil_reservoir_synthesizer import OilSimulator +from resdata.summary import Summary def globalIndex(i, j, k, nx=10, ny=10): @@ -31,50 +31,50 @@ def read_parameters(filename): def runSimulator(simulator, history_simulator, time_step_count): - ecl_sum = EclSum.writer("SNAKE_OIL_FIELD", datetime(2010, 1, 1), 10, 10, 10) - - ecl_sum.addVariable("FOPT") - ecl_sum.addVariable("FOPR") - ecl_sum.addVariable("FGPT") - ecl_sum.addVariable("FGPR") - ecl_sum.addVariable("FWPT") - ecl_sum.addVariable("FWPR") - ecl_sum.addVariable("FGOR") - ecl_sum.addVariable("FWCT") - - ecl_sum.addVariable("FOPTH") - ecl_sum.addVariable("FOPRH") - ecl_sum.addVariable("FGPTH") - ecl_sum.addVariable("FGPRH") - ecl_sum.addVariable("FWPTH") - ecl_sum.addVariable("FWPRH") - ecl_sum.addVariable("FGORH") - ecl_sum.addVariable("FWCTH") - - ecl_sum.addVariable("WOPR", wgname="OP1") - ecl_sum.addVariable("WOPR", wgname="OP2") - ecl_sum.addVariable("WWPR", wgname="OP1") - ecl_sum.addVariable("WWPR", wgname="OP2") - ecl_sum.addVariable("WGPR", wgname="OP1") - ecl_sum.addVariable("WGPR", wgname="OP2") - ecl_sum.addVariable("WGOR", wgname="OP1") - ecl_sum.addVariable("WGOR", wgname="OP2") - ecl_sum.addVariable("WWCT", wgname="OP1") - ecl_sum.addVariable("WWCT", wgname="OP2") - - ecl_sum.addVariable("WOPRH", wgname="OP1") - ecl_sum.addVariable("WOPRH", wgname="OP2") - ecl_sum.addVariable("WWPRH", wgname="OP1") - ecl_sum.addVariable("WWPRH", wgname="OP2") - ecl_sum.addVariable("WGPRH", wgname="OP1") - ecl_sum.addVariable("WGPRH", wgname="OP2") - ecl_sum.addVariable("WGORH", wgname="OP1") - ecl_sum.addVariable("WGORH", wgname="OP2") - ecl_sum.addVariable("WWCTH", wgname="OP1") - ecl_sum.addVariable("WWCTH", wgname="OP2") - - ecl_sum.addVariable("BPR", num=globalIndex(5, 5, 5)) - ecl_sum.addVariable("BPR", num=globalIndex(1, 3, 8)) + summary = Summary.writer("SNAKE_OIL_FIELD", datetime(2010, 1, 1), 10, 10, 10) + + summary.add_variable("FOPT") + summary.add_variable("FOPR") + summary.add_variable("FGPT") + summary.add_variable("FGPR") + summary.add_variable("FWPT") + summary.add_variable("FWPR") + summary.add_variable("FGOR") + summary.add_variable("FWCT") + + summary.add_variable("FOPTH") + summary.add_variable("FOPRH") + summary.add_variable("FGPTH") + summary.add_variable("FGPRH") + summary.add_variable("FWPTH") + summary.add_variable("FWPRH") + summary.add_variable("FGORH") + summary.add_variable("FWCTH") + + summary.add_variable("WOPR", wgname="OP1") + summary.add_variable("WOPR", wgname="OP2") + summary.add_variable("WWPR", wgname="OP1") + summary.add_variable("WWPR", wgname="OP2") + summary.add_variable("WGPR", wgname="OP1") + summary.add_variable("WGPR", wgname="OP2") + summary.add_variable("WGOR", wgname="OP1") + summary.add_variable("WGOR", wgname="OP2") + summary.add_variable("WWCT", wgname="OP1") + summary.add_variable("WWCT", wgname="OP2") + + summary.add_variable("WOPRH", wgname="OP1") + summary.add_variable("WOPRH", wgname="OP2") + summary.add_variable("WWPRH", wgname="OP1") + summary.add_variable("WWPRH", wgname="OP2") + summary.add_variable("WGPRH", wgname="OP1") + summary.add_variable("WGPRH", wgname="OP2") + summary.add_variable("WGORH", wgname="OP1") + summary.add_variable("WGORH", wgname="OP2") + summary.add_variable("WWCTH", wgname="OP1") + summary.add_variable("WWCTH", wgname="OP2") + + summary.add_variable("BPR", num=globalIndex(5, 5, 5)) + summary.add_variable("BPR", num=globalIndex(1, 3, 8)) time_map = [] mini_step_count = 10 @@ -82,11 +82,11 @@ def runSimulator(simulator, history_simulator, time_step_count): for report_step in range(time_step_count): for mini_step in range(mini_step_count): - t_step = ecl_sum.addTStep( + t_step = summary.add_t_step( report_step + 1, sim_days=report_step * mini_step_count + mini_step ) - time_map.append(t_step.getSimTime().datetime().strftime("%d/%m/%Y")) + time_map.append(t_step.get_sim_time().datetime().strftime("%d/%m/%Y")) simulator.step(scale=1.0 / total_step_count) history_simulator.step(scale=1.0 / total_step_count) @@ -142,7 +142,7 @@ def runSimulator(simulator, history_simulator, time_step_count): t_step["WWCTH:OP1"] = history_simulator.wct("OP1") t_step["WWCTH:OP2"] = history_simulator.wct("OP2") - return ecl_sum, time_map + return summary, time_map def roundedInt(value): diff --git a/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_diff.py b/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_diff.py index 0dd82851167..bce00d3f035 100755 --- a/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_diff.py +++ b/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_diff.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -from ecl.summary import EclSum +from resdata.summary import Summary def writeDiff(filename, ecl_sum, key1, key2): @@ -10,9 +10,9 @@ def writeDiff(filename, ecl_sum, key1, key2): if __name__ == "__main__": - ecl_sum = EclSum("SNAKE_OIL_FIELD") + summary = Summary("SNAKE_OIL_FIELD") report_step = 199 - writeDiff(f"snake_oil_opr_diff_{report_step}.txt", ecl_sum, "WOPR:OP1", "WOPR:OP2") - writeDiff(f"snake_oil_wpr_diff_{report_step}.txt", ecl_sum, "WWPR:OP1", "WWPR:OP2") - writeDiff(f"snake_oil_gpr_diff_{report_step}.txt", ecl_sum, "WGPR:OP1", "WGPR:OP2") + writeDiff(f"snake_oil_opr_diff_{report_step}.txt", summary, "WOPR:OP1", "WOPR:OP2") + writeDiff(f"snake_oil_wpr_diff_{report_step}.txt", summary, "WWPR:OP1", "WWPR:OP2") + writeDiff(f"snake_oil_gpr_diff_{report_step}.txt", summary, "WGPR:OP1", "WGPR:OP2") diff --git a/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_npv.py b/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_npv.py index 263f4903bda..bbb3ab49065 100755 --- a/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_npv.py +++ b/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_npv.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -from ecl.summary import EclSum +from resdata.summary import Summary OIL_PRICES = { "2010-01-01": 78.33, @@ -74,10 +74,10 @@ } if __name__ == "__main__": - ecl_sum = EclSum("SNAKE_OIL_FIELD") - start_time = ecl_sum.getStartTime() - date_ranges = ecl_sum.timeRange(start_time, interval="1M") - production_sums = ecl_sum.blockedProduction("FOPT", date_ranges) + summary = Summary("SNAKE_OIL_FIELD") + start_time = summary.get_start_time() + date_ranges = summary.time_range(start_time, interval="1M") + production_sums = summary.blocked_production("FOPT", date_ranges) npv = 0.0 for index in range(0, len(date_ranges) - 1): diff --git a/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_simulator.py b/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_simulator.py index 78041764566..4e6e8d1a0c9 100755 --- a/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_simulator.py +++ b/test-data/snake_oil_structure/snake_oil/jobs/snake_oil_simulator.py @@ -2,8 +2,8 @@ from datetime import datetime from typing import List, Tuple -from ecl.summary import EclSum from oil_reservoir_synthesizer import OilSimulator +from resdata.summary import Summary def globalIndex(i, j, k, nx=10, ny=10, nz=10): @@ -22,51 +22,51 @@ def readParameters(filename): def runSimulator( simulator, history_simulator, time_step_count -) -> Tuple[EclSum, List[str]]: - ecl_sum = EclSum.writer("SNAKE_OIL_FIELD", datetime(2010, 1, 1), 10, 10, 10) - - ecl_sum.addVariable("FOPT") - ecl_sum.addVariable("FOPR") - ecl_sum.addVariable("FGPT") - ecl_sum.addVariable("FGPR") - ecl_sum.addVariable("FWPT") - ecl_sum.addVariable("FWPR") - ecl_sum.addVariable("FGOR") - ecl_sum.addVariable("FWCT") - - ecl_sum.addVariable("FOPTH") - ecl_sum.addVariable("FOPRH") - ecl_sum.addVariable("FGPTH") - ecl_sum.addVariable("FGPRH") - ecl_sum.addVariable("FWPTH") - ecl_sum.addVariable("FWPRH") - ecl_sum.addVariable("FGORH") - ecl_sum.addVariable("FWCTH") - - ecl_sum.addVariable("WOPR", wgname="OP1") - ecl_sum.addVariable("WOPR", wgname="OP2") - ecl_sum.addVariable("WWPR", wgname="OP1") - ecl_sum.addVariable("WWPR", wgname="OP2") - ecl_sum.addVariable("WGPR", wgname="OP1") - ecl_sum.addVariable("WGPR", wgname="OP2") - ecl_sum.addVariable("WGOR", wgname="OP1") - ecl_sum.addVariable("WGOR", wgname="OP2") - ecl_sum.addVariable("WWCT", wgname="OP1") - ecl_sum.addVariable("WWCT", wgname="OP2") - - ecl_sum.addVariable("WOPRH", wgname="OP1") - ecl_sum.addVariable("WOPRH", wgname="OP2") - ecl_sum.addVariable("WWPRH", wgname="OP1") - ecl_sum.addVariable("WWPRH", wgname="OP2") - ecl_sum.addVariable("WGPRH", wgname="OP1") - ecl_sum.addVariable("WGPRH", wgname="OP2") - ecl_sum.addVariable("WGORH", wgname="OP1") - ecl_sum.addVariable("WGORH", wgname="OP2") - ecl_sum.addVariable("WWCTH", wgname="OP1") - ecl_sum.addVariable("WWCTH", wgname="OP2") - - ecl_sum.addVariable("BPR", num=globalIndex(5, 5, 5)) - ecl_sum.addVariable("BPR", num=globalIndex(1, 3, 8)) +) -> Tuple[Summary, List[str]]: + summary = Summary.writer("SNAKE_OIL_FIELD", datetime(2010, 1, 1), 10, 10, 10) + + summary.add_variable("FOPT") + summary.add_variable("FOPR") + summary.add_variable("FGPT") + summary.add_variable("FGPR") + summary.add_variable("FWPT") + summary.add_variable("FWPR") + summary.add_variable("FGOR") + summary.add_variable("FWCT") + + summary.add_variable("FOPTH") + summary.add_variable("FOPRH") + summary.add_variable("FGPTH") + summary.add_variable("FGPRH") + summary.add_variable("FWPTH") + summary.add_variable("FWPRH") + summary.add_variable("FGORH") + summary.add_variable("FWCTH") + + summary.add_variable("WOPR", wgname="OP1") + summary.add_variable("WOPR", wgname="OP2") + summary.add_variable("WWPR", wgname="OP1") + summary.add_variable("WWPR", wgname="OP2") + summary.add_variable("WGPR", wgname="OP1") + summary.add_variable("WGPR", wgname="OP2") + summary.add_variable("WGOR", wgname="OP1") + summary.add_variable("WGOR", wgname="OP2") + summary.add_variable("WWCT", wgname="OP1") + summary.add_variable("WWCT", wgname="OP2") + + summary.add_variable("WOPRH", wgname="OP1") + summary.add_variable("WOPRH", wgname="OP2") + summary.add_variable("WWPRH", wgname="OP1") + summary.add_variable("WWPRH", wgname="OP2") + summary.add_variable("WGPRH", wgname="OP1") + summary.add_variable("WGPRH", wgname="OP2") + summary.add_variable("WGORH", wgname="OP1") + summary.add_variable("WGORH", wgname="OP2") + summary.add_variable("WWCTH", wgname="OP1") + summary.add_variable("WWCTH", wgname="OP2") + + summary.add_variable("BPR", num=globalIndex(5, 5, 5)) + summary.add_variable("BPR", num=globalIndex(1, 3, 8)) time_map = [] mini_step_count = 10 @@ -74,7 +74,7 @@ def runSimulator( for report_step in range(time_step_count): for mini_step in range(mini_step_count): - t_step = ecl_sum.addTStep( + t_step = summary.addTStep( report_step + 1, sim_days=report_step * mini_step_count + mini_step ) @@ -134,7 +134,7 @@ def runSimulator( t_step["WWCTH:OP1"] = history_simulator.wct("OP1") t_step["WWCTH:OP2"] = history_simulator.wct("OP2") - return ecl_sum, time_map + return summary, time_map def roundedInt(value): diff --git a/tests/performance_tests/performance_utils.py b/tests/performance_tests/performance_utils.py index 6b7ee66a1ca..0a0dbd84704 100644 --- a/tests/performance_tests/performance_utils.py +++ b/tests/performance_tests/performance_utils.py @@ -8,9 +8,9 @@ import numpy import py import resfo -from ecl.summary import EclSum from jinja2 import Environment, FileSystemLoader from numpy import array +from resdata.summary import Summary from ert.dark_storage import enkf @@ -97,11 +97,11 @@ def make_poly_example(folder, source, **kwargs): update_steps, ) else: - ecl_sum = EclSum.writer( + summary = Summary.writer( str(folder) + "/refcase/REFCASE", datetime.datetime(2010, 1, 1), 10, 10, 10 ) for s in range(summary_count): - ecl_sum.addVariable(f"PSUM{s}") + summary.add_variable(f"PSUM{s}") render_template( folder, env.get_template("poly_obs_data.txt.j2"), @@ -110,12 +110,12 @@ def make_poly_example(folder, source, **kwargs): ) for x in range(summary_data_entries * update_steps): - t_step = ecl_sum.addTStep(x // update_steps + 1, sim_days=x + 1) + t_step = summary.add_t_step(x // update_steps + 1, sim_days=x + 1) for s in range(summary_count): t_step[f"PSUM{s}"] = 5.0 if summary_count > 0: - ecl_sum.fwrite() + summary.fwrite() return folder diff --git a/tests/unit_tests/config/config_dict_generator.py b/tests/unit_tests/config/config_dict_generator.py index 22fa71ec35d..00c629a6da4 100644 --- a/tests/unit_tests/config/config_dict_generator.py +++ b/tests/unit_tests/config/config_dict_generator.py @@ -8,10 +8,10 @@ from typing import Any, List, Literal, Optional, Tuple, Union import hypothesis.strategies as st -from ecl.summary import EclSum, EclSumVarType from hypothesis import assume, note from py import path as py_path from pydantic import PositiveInt +from resdata.summary import Summary, SummaryVarType from ert import _clib from ert.config import ( @@ -334,22 +334,22 @@ def all_defines(self, config_file, cwd): def composite_keys(smspec: Smspec) -> st.SearchStrategy[str]: """ - The History observation format uses the EclSum "composit keys" - format to identify values (See ecl.summary.EclSum documentation) + The History observation format uses the Summary "composit keys" + format to identify values (See resdata.summary.Summary documentation) """ generators = [] for index in range(1, len(smspec.keywords)): # assume index 0 is time summary_key = smspec.keywords[index] - var_type = EclSum.var_type(summary_key) + var_type = Summary.var_type(summary_key) if var_type in [ - EclSumVarType.ECL_SMSPEC_FIELD_VAR, - EclSumVarType.ECL_SMSPEC_MISC_VAR, + SummaryVarType.RD_SMSPEC_FIELD_VAR, + SummaryVarType.RD_SMSPEC_MISC_VAR, ]: generators.append(st.just(summary_key)) if var_type in [ - EclSumVarType.ECL_SMSPEC_COMPLETION_VAR, - EclSumVarType.ECL_SMSPEC_SEGMENT_VAR, + SummaryVarType.RD_SMSPEC_COMPLETION_VAR, + SummaryVarType.RD_SMSPEC_SEGMENT_VAR, ]: generators.append( st.just( @@ -359,14 +359,14 @@ def composite_keys(smspec: Smspec) -> st.SearchStrategy[str]: ) ) if var_type in [ - EclSumVarType.ECL_SMSPEC_GROUP_VAR, - EclSumVarType.ECL_SMSPEC_WELL_VAR, + SummaryVarType.RD_SMSPEC_GROUP_VAR, + SummaryVarType.RD_SMSPEC_WELL_VAR, ]: generators.append(st.just(f"{summary_key}:{smspec.well_names[index]}")) if var_type in [ - EclSumVarType.ECL_SMSPEC_AQUIFER_VAR, - EclSumVarType.ECL_SMSPEC_REGION_VAR, - EclSumVarType.ECL_SMSPEC_BLOCK_VAR, + SummaryVarType.RD_SMSPEC_AQUIFER_VAR, + SummaryVarType.RD_SMSPEC_REGION_VAR, + SummaryVarType.RD_SMSPEC_BLOCK_VAR, ]: generators.append(st.just(f"{summary_key}:{smspec.region_numbers[index]}")) diff --git a/tests/unit_tests/config/test_ensemble_config.py b/tests/unit_tests/config/test_ensemble_config.py index 76dcce76a26..07fe2f45b3a 100644 --- a/tests/unit_tests/config/test_ensemble_config.py +++ b/tests/unit_tests/config/test_ensemble_config.py @@ -5,7 +5,7 @@ import pytest import xtgeo -from ecl.summary import EclSum +from resdata.summary import Summary from ert.config import ConfigValidationError, EnsembleConfig, ErtConfig from ert.config.parsing import ConfigKeys @@ -50,11 +50,11 @@ def test_ensemble_config_construct_refcase_and_grid(): grid_file = "CASE.EGRID" refcase_file = "REFCASE_NAME" xtgeo.create_box_grid(dimension=(10, 10, 1)).to_file("CASE.EGRID", "egrid") - ecl_sum = EclSum.writer("REFCASE_NAME", datetime(2014, 9, 10), 3, 3, 3) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - t_step = ecl_sum.addTStep(1, sim_days=10) + summary = Summary.writer("REFCASE_NAME", datetime(2014, 9, 10), 3, 3, 3) + summary.add_variable("FOPR", unit="SM3/DAY") + t_step = summary.add_t_step(1, sim_days=10) t_step["FOPR"] = 10 - ecl_sum.fwrite() + summary.fwrite() ec = EnsembleConfig.from_dict( config_dict={ ConfigKeys.GRID: grid_file, @@ -63,7 +63,7 @@ def test_ensemble_config_construct_refcase_and_grid(): ) assert isinstance(ec, EnsembleConfig) - assert isinstance(ec.refcase, EclSum) + assert isinstance(ec.refcase, Summary) assert ec.grid_file == os.path.realpath(grid_file) @@ -75,11 +75,11 @@ def test_that_refcase_gets_correct_name(tmpdir): } with tmpdir.as_cwd(): - ecl_sum = EclSum.writer(refcase_name, datetime(2014, 9, 10), 10, 10, 10) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - t_step = ecl_sum.addTStep(2, sim_days=1) + summary = Summary.writer(refcase_name, datetime(2014, 9, 10), 10, 10, 10) + summary.add_variable("FOPR", unit="SM3/DAY") + t_step = summary.add_t_step(2, sim_days=1) t_step["FOPR"] = 1 - ecl_sum.fwrite() + summary.fwrite() ec = EnsembleConfig.from_dict(config_dict=config_dict) assert os.path.realpath(refcase_name) == ec.refcase.case diff --git a/tests/unit_tests/config/test_observations.py b/tests/unit_tests/config/test_observations.py index 496a2baebe4..b89d3d1f745 100644 --- a/tests/unit_tests/config/test_observations.py +++ b/tests/unit_tests/config/test_observations.py @@ -6,9 +6,9 @@ import numpy as np import pytest -from ecl.summary import EclSum from hypothesis import given, settings from hypothesis import strategies as st +from resdata.summary import Summary from ert.config import ( ConfigValidationError, @@ -30,19 +30,19 @@ def run_simulator(): Create an ecl summary file, we have one value for FOPR (1) and a different for FOPRH (2) so we can assert on the difference. """ - ecl_sum = EclSum.writer("MY_REFCASE", datetime(2000, 1, 1), 10, 10, 10) + summary = Summary.writer("MY_REFCASE", datetime(2000, 1, 1), 10, 10, 10) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - ecl_sum.addVariable("FOPRH", unit="SM3/DAY") + summary.add_variable("FOPR", unit="SM3/DAY") + summary.add_variable("FOPRH", unit="SM3/DAY") mini_step_count = 10 for mini_step in range(mini_step_count): - t_step = ecl_sum.addTStep(1, sim_days=mini_step_count + mini_step) + t_step = summary.addTStep(1, sim_days=mini_step_count + mini_step) t_step["FOPR"] = 1 t_step["FOPRH"] = 2 - ecl_sum.fwrite() + summary.fwrite() @pytest.mark.parametrize( @@ -462,17 +462,17 @@ def run_sim(start_date, keys=None, values=None, days=None): keys = keys if keys else [("FOPR", "SM3/DAY", None)] values = {} if values is None else values days = [1] if days is None else days - ecl_sum = EclSum.writer("ECLIPSE_CASE", start_date, 3, 3, 3) + summary = Summary.writer("ECLIPSE_CASE", start_date, 3, 3, 3) for key, unit, wname in keys: - ecl_sum.addVariable(key, unit=unit, wgname=wname) + summary.add_variable(key, unit=unit, wgname=wname) for i in days: - t_step = ecl_sum.addTStep(i, sim_days=i) + t_step = summary.add_t_step(i, sim_days=i) for key, _, wname in keys: if wname is None: t_step[key] = values.get(key, 1) else: t_step[key + ":" + wname] = values.get(key, 1) - ecl_sum.fwrite() + summary.fwrite() @pytest.mark.parametrize( diff --git a/tests/unit_tests/scenarios/test_summary_response.py b/tests/unit_tests/scenarios/test_summary_response.py index 518bb4a7e36..172053275b5 100644 --- a/tests/unit_tests/scenarios/test_summary_response.py +++ b/tests/unit_tests/scenarios/test_summary_response.py @@ -6,7 +6,7 @@ import numpy as np import pytest -from ecl.summary import EclSum +from resdata.summary import Summary from ert import LibresFacade from ert.analysis import ErtAnalysisError, UpdateConfiguration, smoother_update @@ -179,14 +179,14 @@ def run_sim(dates, value, fname="ECLIPSE_CASE"): Create a summary file, the contents of which are not important """ start_date = dates[0] - ecl_sum = EclSum.writer(fname, start_date, 3, 3, 3) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") + summary = Summary.writer(fname, start_date, 3, 3, 3) + summary.add_variable("FOPR", unit="SM3/DAY") for report_step, date in enumerate(dates): - t_step = ecl_sum.addTStep( + t_step = summary.add_t_step( report_step + 1, sim_days=(date + timedelta(days=1) - start_date).days ) t_step["FOPR"] = value - ecl_sum.fwrite() + summary.fwrite() def test_that_duplicate_summary_time_steps_does_not_fail( diff --git a/tests/unit_tests/shared/share/test_ecl_run.py b/tests/unit_tests/shared/share/test_ecl_run.py index 2463dcd9d2f..952e1bb9a03 100644 --- a/tests/unit_tests/shared/share/test_ecl_run.py +++ b/tests/unit_tests/shared/share/test_ecl_run.py @@ -9,7 +9,7 @@ import pytest import yaml -from ecl.summary import EclSum +from resdata.summary import Summary from tests.utils import SOURCE_DIR @@ -475,7 +475,7 @@ def test_summary_block(init_ecl100_config, source_root): assert ret_value is None erun.runEclipse() - assert isinstance(erun.summary_block(), EclSum) + assert isinstance(erun.summary_block(), Summary) @pytest.mark.requires_eclipse diff --git a/tests/unit_tests/shared/share/test_ecl_run_new_config.py b/tests/unit_tests/shared/share/test_ecl_run_new_config.py index c1695add7c0..a1370b8c637 100644 --- a/tests/unit_tests/shared/share/test_ecl_run_new_config.py +++ b/tests/unit_tests/shared/share/test_ecl_run_new_config.py @@ -8,7 +8,7 @@ import pytest import yaml -from ecl.summary import EclSum +from resdata.summary import Summary from tests.utils import SOURCE_DIR @@ -242,4 +242,4 @@ def test_summary_block(source_root): erun.runEclipse(eclrun_config=ecl_config.EclrunConfig(econfig, "2019.3")) ecl_sum = erun.summary_block() - assert isinstance(ecl_sum, EclSum) + assert isinstance(ecl_sum, Summary) diff --git a/tests/unit_tests/status/test_tracking_integration.py b/tests/unit_tests/status/test_tracking_integration.py index 936ca3203d4..fbe94b5c72f 100644 --- a/tests/unit_tests/status/test_tracking_integration.py +++ b/tests/unit_tests/status/test_tracking_integration.py @@ -10,8 +10,8 @@ from textwrap import dedent import pytest -from ecl.summary import EclSum from jsonpath_ng import parse +from resdata.summary import Summary from ert.__main__ import ert_parser from ert.cli import ENSEMBLE_EXPERIMENT_MODE, ENSEMBLE_SMOOTHER_MODE, TEST_RUN_MODE @@ -359,11 +359,11 @@ def run_sim(start_date): """ Create a summary file, the contents of which are not important """ - ecl_sum = EclSum.writer("ECLIPSE_CASE", start_date, 3, 3, 3) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - t_step = ecl_sum.addTStep(1, sim_days=1) + summary = Summary.writer("ECLIPSE_CASE", start_date, 3, 3, 3) + summary.add_variable("FOPR", unit="SM3/DAY") + t_step = summary.add_t_step(1, sim_days=1) t_step["FOPR"] = 1 - ecl_sum.fwrite() + summary.fwrite() @pytest.mark.integration_test diff --git a/tests/unit_tests/storage/test_field_parameter.py b/tests/unit_tests/storage/test_field_parameter.py index 7618c2cf536..b019310e850 100644 --- a/tests/unit_tests/storage/test_field_parameter.py +++ b/tests/unit_tests/storage/test_field_parameter.py @@ -11,10 +11,10 @@ import numpy.testing import pytest import xtgeo -from ecl import EclDataType -from ecl.eclfile import EclKW -from ecl.grid import EclGridGenerator -from ecl.util.geometry import Surface +from resdata import ResDataType +from resdata.geometry import Surface +from resdata.grid import GridGenerator +from resdata.resfile import ResdataKW from ert.__main__ import ert_parser from ert.cli import ENSEMBLE_SMOOTHER_MODE @@ -744,10 +744,12 @@ def test_inactive_grdecl_ecl(tmpdir, storage, actnum): float(i) if mask else missing_value for (i, mask) in enumerate(actnum) ] - grid = EclGridGenerator.create_rectangular((4, 3, 2), (1, 1, 1), actnum=actnum) + grid = GridGenerator.create_rectangular((4, 3, 2), (1, 1, 1), actnum=actnum) grid.save_GRID("MY_GRID.GRID") - expect_param = EclKW("MY_PARAM", grid.get_global_size(), EclDataType.ECL_FLOAT) + expect_param = ResdataKW( + "MY_PARAM", grid.get_global_size(), ResDataType.RD_FLOAT + ) for i in range(grid.get_global_size()): expect_param[i] = i @@ -762,7 +764,7 @@ def test_inactive_grdecl_ecl(tmpdir, storage, actnum): with cwrap.open( f"simulations/realization-0/iter-0/my_param.{fformat}", "rb" ) as f: - actual_param = EclKW.read_grdecl(f, "MY_PARAM") + actual_param = ResdataKW.read_grdecl(f, "MY_PARAM") read_result = list(actual_param.numpy_view()) numpy.testing.assert_array_equal(read_result, expected_result) diff --git a/tests/unit_tests/storage/test_local_ensemble.py b/tests/unit_tests/storage/test_local_ensemble.py index 53f607086a8..3eb448d99c0 100644 --- a/tests/unit_tests/storage/test_local_ensemble.py +++ b/tests/unit_tests/storage/test_local_ensemble.py @@ -2,7 +2,7 @@ import pytest import xarray as xr import xtgeo -from ecl.grid import EclGridGenerator +from resdata.grid import GridGenerator from ert.storage import open_storage @@ -41,7 +41,7 @@ def test_that_grid_files_are_saved_and_loaded_correctly(tmp_path): assert ensemble_dir.exists() mask = [True] * 3 + [False] * 16 + [True] - grid = EclGridGenerator.create_rectangular((4, 5, 1), (1, 1, 1), actnum=mask) + grid = GridGenerator.create_rectangular((4, 5, 1), (1, 1, 1), actnum=mask) grid.save_GRID(f"{experiment.mount_point}/grid.GRID") data = np.full_like(mask, np.nan, dtype=np.float32) diff --git a/tests/unit_tests/storage/test_parameter_sample_types.py b/tests/unit_tests/storage/test_parameter_sample_types.py index 4d77d3dfb7a..fe9281431ac 100644 --- a/tests/unit_tests/storage/test_parameter_sample_types.py +++ b/tests/unit_tests/storage/test_parameter_sample_types.py @@ -12,8 +12,8 @@ import numpy as np import pytest import xtgeo -from ecl.util.geometry import Surface from flaky import flaky +from resdata.geometry import Surface from ert.__main__ import ert_parser from ert.cli import ENSEMBLE_SMOOTHER_MODE diff --git a/tests/unit_tests/test_libres_facade.py b/tests/unit_tests/test_libres_facade.py index cbe6a220dc8..4f333de4b72 100644 --- a/tests/unit_tests/test_libres_facade.py +++ b/tests/unit_tests/test_libres_facade.py @@ -3,8 +3,8 @@ from textwrap import dedent import pytest -from ecl.summary import EclSum from pandas.core.base import PandasObject +from resdata.summary import Summary from ert.config import ErtConfig from ert.enkf_main import sample_prior @@ -451,11 +451,11 @@ def test_get_observations(tmpdir): with open("observations", "w", encoding="utf-8") as fh: fh.writelines(observations) - ecl_sum = EclSum.writer("ECLIPSE_CASE", date, 3, 3, 3) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - t_step = ecl_sum.addTStep(1, sim_days=1) + summary = Summary.writer("ECLIPSE_CASE", date, 3, 3, 3) + summary.add_variable("FOPR", unit="SM3/DAY") + t_step = summary.add_t_step(1, sim_days=1) t_step["FOPR"] = 1 - ecl_sum.fwrite() + summary.fwrite() facade = LibresFacade.from_config_file("config.ert") assert "FOPR_1" in facade.get_observations() diff --git a/tests/unit_tests/test_load_forward_model.py b/tests/unit_tests/test_load_forward_model.py index 04a87a69ce3..e375d14e519 100644 --- a/tests/unit_tests/test_load_forward_model.py +++ b/tests/unit_tests/test_load_forward_model.py @@ -7,7 +7,7 @@ import numpy as np import pytest -from ecl.summary import EclSum +from resdata.summary import Summary from ert.config import ErtConfig from ert.enkf_main import EnKFMain, create_run_path, ensemble_context @@ -46,19 +46,19 @@ def func(config_text): yield func -def run_simulator(time_step_count, start_date) -> EclSum: - ecl_sum = EclSum.writer("SNAKE_OIL_FIELD", start_date, 10, 10, 10) +def run_simulator(time_step_count, start_date) -> Summary: + summary = Summary.writer("SNAKE_OIL_FIELD", start_date, 10, 10, 10) - ecl_sum.addVariable("FOPR", unit="SM3/DAY") - ecl_sum.addVariable("FOPRH", unit="SM3/DAY") + summary.add_variable("FOPR", unit="SM3/DAY") + summary.add_variable("FOPRH", unit="SM3/DAY") - ecl_sum.addVariable("WOPR", wgname="OP1", unit="SM3/DAY") - ecl_sum.addVariable("WOPRH", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WOPR", wgname="OP1", unit="SM3/DAY") + summary.add_variable("WOPRH", wgname="OP1", unit="SM3/DAY") mini_step_count = 10 for report_step in range(time_step_count): for mini_step in range(mini_step_count): - t_step = ecl_sum.addTStep( + t_step = summary.add_t_step( report_step + 1, sim_days=report_step * mini_step_count + mini_step ) t_step["FOPR"] = 1 @@ -66,7 +66,7 @@ def run_simulator(time_step_count, start_date) -> EclSum: t_step["FOPRH"] = 3 t_step["WOPRH:OP1"] = 4 - return ecl_sum + return summary @pytest.mark.usefixtures("copy_snake_oil_case_storage")