From d3ef53285a42d9d4044e9b6cb7fadef13d43e6d6 Mon Sep 17 00:00:00 2001 From: Magne Sjaastad Date: Mon, 9 Sep 2013 12:13:33 +0200 Subject: [PATCH] Updated to ERT version fix for amalgamated-nnc-bug https://github.com/joakim-hove/ert/commit/e47dfe0ee4e1485f5b70e9b24f33a9d6d1c41902 p4#: 22363 --- ThirdParty/Ert/devel/cmake/ert_check.cmake | 7 +- .../Ert/devel/libanalysis/CMakeLists.txt | 17 +- .../libanalysis/applications/CMakeLists.txt | 8 + .../{module_test.c => ert_module_test.c} | 18 +- .../devel/libanalysis/cmake/ert_module.cmake | 21 + .../include/ert/analysis/analysis_module.h | 2 +- .../devel/libanalysis/modules/CMakeLists.txt | 7 + .../libanalysis/{src => modules}/rml_enkf.c | 16 +- .../{src => modules}/rml_enkf_common.c | 4 +- .../analysis => modules}/rml_enkf_common.h | 0 .../devel/libanalysis/script/CMakeLists.txt | 1 + .../Ert/devel/libanalysis/script/ert_module | 246 ++++++ .../Ert/devel/libanalysis/src/CMakeLists.txt | 19 +- .../Ert/devel/libanalysis/src/ert_module | 167 ---- .../devel/libanalysis/tests/CMakeLists.txt | 1 + .../devel/libecl/include/ert/ecl/nnc_vector.h | 2 +- ThirdParty/Ert/devel/libecl/src/ecl_grid.c | 43 +- ThirdParty/Ert/devel/libecl/src/fortio.c | 1 - ThirdParty/Ert/devel/libecl/src/nnc_vector.c | 15 +- .../devel/libecl/tests/ecl_nnc_amalgamated.c | 34 + .../Ert/devel/libecl/tests/ecl_nnc_test.c | 16 +- .../Ert/devel/libecl/tests/ecl_nnc_vector.c | 5 + ThirdParty/Ert/devel/libecl/tests/tests.cmake | 12 + .../applications/ert_tui/enkf_tui_QC.c | 17 +- .../applications/ert_tui/enkf_tui_run.c | 97 +-- .../include/ert/enkf/analysis_config.h | 8 +- .../include/ert/enkf/analysis_iter_config.h | 2 + .../libenkf/include/ert/enkf/cases_config.h | 39 + .../libenkf/include/ert/enkf/config_keys.h | 1 + .../libenkf/include/ert/enkf/ecl_config.h | 1 + .../libenkf/include/ert/enkf/enkf_defaults.h | 5 +- .../devel/libenkf/include/ert/enkf/enkf_fs.h | 6 +- .../libenkf/include/ert/enkf/enkf_main.h | 14 +- .../devel/libenkf/include/ert/enkf/enkf_obs.h | 3 +- .../libenkf/include/ert/enkf/enkf_state.h | 8 +- .../libenkf/include/ert/enkf/enkf_types.h | 18 +- .../libenkf/include/ert/enkf/meas_data.h | 9 +- .../libenkf/include/ert/enkf/model_config.h | 7 +- .../libenkf/include/ert/enkf/obs_vector.h | 2 +- .../libenkf/include/ert/enkf/state_map.h | 56 ++ .../Ert/devel/libenkf/src/CMakeLists.txt | 4 +- .../Ert/devel/libenkf/src/analysis_config.c | 39 +- .../devel/libenkf/src/analysis_iter_config.c | 46 +- .../Ert/devel/libenkf/src/cases_config.c | 86 ++ ThirdParty/Ert/devel/libenkf/src/ecl_config.c | 19 +- ThirdParty/Ert/devel/libenkf/src/enkf_fs.c | 52 +- ThirdParty/Ert/devel/libenkf/src/enkf_main.c | 445 ++++++++--- .../Ert/devel/libenkf/src/enkf_main_jobs.c | 2 +- ThirdParty/Ert/devel/libenkf/src/enkf_obs.c | 56 +- ThirdParty/Ert/devel/libenkf/src/enkf_state.c | 138 +++- ThirdParty/Ert/devel/libenkf/src/meas_data.c | 51 +- .../Ert/devel/libenkf/src/model_config.c | 24 +- ThirdParty/Ert/devel/libenkf/src/obs_vector.c | 10 +- ThirdParty/Ert/devel/libenkf/src/state_map.c | 245 ++++++ .../Ert/devel/libenkf/tests/CMakeLists.txt | 32 +- .../libenkf/tests/enkf_analysis_config.c | 83 ++ .../devel/libenkf/tests/enkf_cases_config.c | 44 + .../libenkf/tests/enkf_forward_init_FIELD.c | 37 +- .../libenkf/tests/enkf_forward_init_GEN_KW.c | 32 +- .../tests/enkf_forward_init_GEN_PARAM.c | 19 +- .../libenkf/tests/enkf_forward_init_SURFACE.c | 30 +- .../devel/libenkf/tests/enkf_iter_config.c | 9 +- .../Ert/devel/libenkf/tests/enkf_meas_data.c | 52 ++ .../devel/libenkf/tests/enkf_model_config.c | 31 +- .../Ert/devel/libenkf/tests/enkf_state_map.c | 274 +++++++ .../tests/enkf_state_report_step_compatible.c | 85 ++ .../include/ert/util/thread_pool.h | 2 +- .../include/ert/util/type_vector_functions.h | 34 + .../devel/libert_util/include/ert/util/util.h | 8 +- .../Ert/devel/libert_util/src/CMakeLists.txt | 4 +- .../Ert/devel/libert_util/src/string_util.c | 12 +- .../devel/libert_util/src/test_work_area.c | 2 +- .../libert_util/src/type_vector_functions.c | 61 ++ ThirdParty/Ert/devel/libert_util/src/util.c | 2 + .../devel/libert_util/src/util_abort_gnu.c | 77 +- .../devel/libert_util/tests/CMakeLists.txt | 8 + .../tests/ert_util_abort_gnu_tests.c | 44 + .../tests/ert_util_type_vector_functions.c | 106 +++ .../tests/ert_util_type_vector_test.c | 16 +- ThirdParty/Ert/devel/librms/src/makefile | 74 ++ .../python/python/ert/config/CMakeLists.txt | 3 +- .../python/python/ert/config/__init__.py | 6 +- .../python/python/ert/config/config_parser.py | 142 ++-- .../python/ert/config/content_type_enum.py | 29 + .../python/ert/config/unrecognized_enum.py | 24 + .../python/python/ert/cwrap/CMakeLists.txt | 3 + .../devel/python/python/ert/cwrap/__init__.py | 7 +- .../python/python/ert/cwrap/basecclass.py | 78 ++ .../python/python/ert/cwrap/basecenum.py | 141 ++++ .../devel/python/python/ert/cwrap/cclass.py | 29 +- .../python/python/ert/cwrap/cnamespace.py | 25 + .../devel/python/python/ert/cwrap/cwrap.py | 75 +- .../python/python/ert/ecl/CMakeLists.txt | 3 + .../devel/python/python/ert/ecl/ecl_case.py | 14 +- .../devel/python/python/ert/ecl/ecl_queue.py | 6 +- .../devel/python/python/ert/ecl/ecl_region.py | 8 +- .../python/python/ert/ecl/ecl_smspec_node.py | 122 +++ .../devel/python/python/ert/ecl/ecl_sum.py | 755 ++++-------------- .../python/python/ert/ecl/ecl_sum_node.py | 27 + .../python/python/ert/ecl/ecl_sum_vector.py | 281 +++++++ .../python/python/ert/enkf/CMakeLists.txt | 35 +- .../devel/python/python/ert/enkf/__init__.py | 25 + .../python/python/ert/enkf/analysis_config.py | 87 +- .../devel/python/python/ert/enkf/block_obs.py | 60 +- .../python/ert/enkf/data/CMakeLists.txt | 12 + .../python/python/ert/enkf/data/__init__.py | 10 + .../python/ert/enkf/data/enkf_config_node.py | 95 +++ .../python/python/ert/enkf/data/enkf_node.py | 58 ++ .../python/python/ert/enkf/data/field.py | 39 + .../python/ert/enkf/data/field_config.py | 74 ++ .../python/ert/enkf/data/gen_data_config.py | 58 ++ .../python/ert/enkf/data/gen_kw_config.py | 47 ++ .../data/summary_config.py} | 19 +- .../python/python/ert/enkf/ecl_config.py | 119 ++- .../Ert/devel/python/python/ert/enkf/enkf.py | 3 - .../python/ert/enkf/enkf_config_node.py | 95 --- .../devel/python/python/ert/enkf/enkf_enum.py | 9 +- .../devel/python/python/ert/enkf/enkf_fs.py | 74 +- .../devel/python/python/ert/enkf/enkf_main.py | 390 +++++---- .../devel/python/python/ert/enkf/enkf_node.py | 66 -- .../devel/python/python/ert/enkf/enkf_obs.py | 63 +- .../python/python/ert/enkf/enkf_state.py | 68 +- .../python/python/ert/enkf/ens_config.py | 96 ++- .../python/python/ert/enkf/ert_template.py | 54 +- .../python/python/ert/enkf/ert_templates.py | 70 +- .../Ert/devel/python/python/ert/enkf/field.py | 48 -- .../python/python/ert/enkf/field_config.py | 87 -- .../python/python/ert/enkf/gen_data_config.py | 71 -- .../python/python/ert/enkf/gen_kw_config.py | 55 -- .../devel/python/python/ert/enkf/libenkf.py | 26 - .../python/python/ert/enkf/local_config.py | 57 +- .../python/python/ert/enkf/model_config.py | 107 +-- .../python/python/ert/enkf/obs_vector.py | 60 -- .../devel/python/python/ert/enkf/plot_conf.py | 103 --- .../python/python/ert/enkf/plot_config.py | 98 +++ .../python/python/ert/enkf/site_config.py | 209 +++-- .../devel/python/python/ert/enkf/time_map.py | 53 -- .../python/ert/enkf/util/CMakeLists.txt | 8 + .../python/python/ert/enkf/util/__init__.py | 4 + .../python/python/ert/enkf/util/obs_vector.py | 56 ++ .../python/python/ert/enkf/util/time_map.py | 45 ++ .../python/python/ert/job_queue/ext_job.py | 144 ++-- .../python/ert/job_queue/ext_joblist.py | 62 +- .../python/ert/job_queue/forward_model.py | 52 +- .../python/python/ert/job_queue/queue.py | 126 ++- .../python/python/ert/sched/CMakeLists.txt | 3 +- .../devel/python/python/ert/sched/__init__.py | 3 +- .../devel/python/python/ert/sched/history.py | 58 +- .../python/ert/sched/history_source_enum.py | 13 + .../python/python/ert/sched/sched_file.py | 38 +- .../python/python/ert/util/CMakeLists.txt | 1 + .../devel/python/python/ert/util/__init__.py | 6 +- .../devel/python/python/ert/util/buffer.py | 21 +- .../Ert/devel/python/python/ert/util/hash.py | 140 +++- .../Ert/devel/python/python/ert/util/log.py | 35 +- .../python/python/ert/util/lookup_table.py | 49 +- .../python/python/ert/util/stringlist.py | 89 +-- .../python/ert/util/substitution_list.py | 46 ++ .../devel/python/python/ert/util/test_area.py | 40 +- .../devel/python/python/ert/util/tvector.py | 584 +++++--------- .../python/ert_gui/pages/application.py | 2 +- .../Ert/devel/python/test/CMakeLists.txt | 41 +- .../test/ert_tests/config/test_config.py | 18 +- .../python/test/ert_tests/cwrap/__init__.py | 0 .../test/ert_tests/cwrap/test_basecclass.py | 12 + .../test/ert_tests/cwrap/test_basecenum.py | 83 ++ .../python/test/ert_tests/cwrap/test_cwrap.py | 66 ++ .../test/ert_tests/ecl/test_ecl_file.py | 2 +- .../test/ert_tests/ecl/test_ecl_submit.py | 27 +- .../python/test/ert_tests/ecl/test_fortio.py | 3 +- .../python/test/ert_tests/ecl/test_grid.py | 3 +- .../python/test/ert_tests/ecl/test_kw.py | 2 +- .../python/test/ert_tests/ecl/test_region.py | 7 +- .../python/test/ert_tests/ecl/test_sum.py | 10 +- .../python/test/ert_tests/enkf/__init__.py | 0 .../python/test/ert_tests/enkf/test_enkf.py | 65 ++ .../test/ert_tests/enkf/test_enkf_library.py | 53 ++ .../test/ert_tests/test_ert_gui_import.py | 173 ++-- .../python/test/ert_tests/test_ert_import.py | 53 +- .../python/test/ert_tests/util/test_hash.py | 75 ++ .../python/test/ert_tests/util/test_latex.py | 19 +- .../test/ert_tests/util/test_string_list.py | 11 +- .../ert_tests/util/test_substitution_list.py | 24 + .../test/ert_tests/util/test_vectors.py | 6 - .../local/simple_config/minimum_config | 6 + .../test-data/local/simple_config/script.sh | 2 + 186 files changed, 6376 insertions(+), 3838 deletions(-) create mode 100644 ThirdParty/Ert/devel/libanalysis/applications/CMakeLists.txt rename ThirdParty/Ert/devel/libanalysis/applications/{module_test.c => ert_module_test.c} (91%) create mode 100644 ThirdParty/Ert/devel/libanalysis/cmake/ert_module.cmake create mode 100644 ThirdParty/Ert/devel/libanalysis/modules/CMakeLists.txt rename ThirdParty/Ert/devel/libanalysis/{src => modules}/rml_enkf.c (96%) rename ThirdParty/Ert/devel/libanalysis/{src => modules}/rml_enkf_common.c (98%) rename ThirdParty/Ert/devel/libanalysis/{include/ert/analysis => modules}/rml_enkf_common.h (100%) create mode 100644 ThirdParty/Ert/devel/libanalysis/script/CMakeLists.txt create mode 100644 ThirdParty/Ert/devel/libanalysis/script/ert_module delete mode 100644 ThirdParty/Ert/devel/libanalysis/src/ert_module create mode 100644 ThirdParty/Ert/devel/libanalysis/tests/CMakeLists.txt create mode 100644 ThirdParty/Ert/devel/libecl/tests/ecl_nnc_amalgamated.c create mode 100644 ThirdParty/Ert/devel/libenkf/include/ert/enkf/cases_config.h create mode 100644 ThirdParty/Ert/devel/libenkf/include/ert/enkf/state_map.h create mode 100644 ThirdParty/Ert/devel/libenkf/src/cases_config.c create mode 100644 ThirdParty/Ert/devel/libenkf/src/state_map.c create mode 100644 ThirdParty/Ert/devel/libenkf/tests/enkf_analysis_config.c create mode 100644 ThirdParty/Ert/devel/libenkf/tests/enkf_cases_config.c create mode 100644 ThirdParty/Ert/devel/libenkf/tests/enkf_meas_data.c create mode 100644 ThirdParty/Ert/devel/libenkf/tests/enkf_state_map.c create mode 100644 ThirdParty/Ert/devel/libenkf/tests/enkf_state_report_step_compatible.c create mode 100644 ThirdParty/Ert/devel/libert_util/include/ert/util/type_vector_functions.h create mode 100644 ThirdParty/Ert/devel/libert_util/src/type_vector_functions.c create mode 100644 ThirdParty/Ert/devel/libert_util/tests/ert_util_abort_gnu_tests.c create mode 100644 ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_functions.c create mode 100644 ThirdParty/Ert/devel/librms/src/makefile create mode 100644 ThirdParty/Ert/devel/python/python/ert/config/content_type_enum.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/config/unrecognized_enum.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/cwrap/basecclass.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/cwrap/basecenum.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/cwrap/cnamespace.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/ecl/ecl_smspec_node.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_node.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_vector.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/CMakeLists.txt create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/__init__.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_config_node.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_node.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/field.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/field_config.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_data_config.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_kw_config.py rename ThirdParty/Ert/devel/python/python/ert/{config/config_enums.py => enkf/data/summary_config.py} (51%) delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/enkf.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/enkf_config_node.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/enkf_node.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/field.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/field_config.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/gen_data_config.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/gen_kw_config.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/libenkf.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/obs_vector.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/plot_conf.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/plot_config.py delete mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/time_map.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/util/CMakeLists.txt create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/util/__init__.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/util/obs_vector.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/enkf/util/time_map.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/sched/history_source_enum.py create mode 100644 ThirdParty/Ert/devel/python/python/ert/util/substitution_list.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/cwrap/__init__.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecclass.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecenum.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_cwrap.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/enkf/__init__.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf_library.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/util/test_hash.py create mode 100644 ThirdParty/Ert/devel/python/test/ert_tests/util/test_substitution_list.py create mode 100644 ThirdParty/Ert/devel/python/test/test-data/local/simple_config/minimum_config create mode 100644 ThirdParty/Ert/devel/python/test/test-data/local/simple_config/script.sh diff --git a/ThirdParty/Ert/devel/cmake/ert_check.cmake b/ThirdParty/Ert/devel/cmake/ert_check.cmake index 7f0cf3e77f..13817386cb 100644 --- a/ThirdParty/Ert/devel/cmake/ert_check.cmake +++ b/ThirdParty/Ert/devel/cmake/ert_check.cmake @@ -74,13 +74,16 @@ if (HAVE_SETENV) add_definitions( -DPOSIX_SETENV ) endif() - - check_function_exists( opendir HAVE_OPENDIR ) if (HAVE_OPENDIR) add_definitions( -DHAVE_OPENDIR ) endif() +check_function_exists( getpwuid HAVE_GETPWUID ) +if (HAVE_GETPWUID) + add_definitions( -DHAVE_GETPWUID ) +endif() + # The usleep() check uses the symbol HAVE__USLEEP with double # underscore to avoid conflict with plplot which defines the # HAVE_USLEEP symbol. diff --git a/ThirdParty/Ert/devel/libanalysis/CMakeLists.txt b/ThirdParty/Ert/devel/libanalysis/CMakeLists.txt index c1aa34ba2b..a21ab5641f 100644 --- a/ThirdParty/Ert/devel/libanalysis/CMakeLists.txt +++ b/ThirdParty/Ert/devel/libanalysis/CMakeLists.txt @@ -1,9 +1,14 @@ +include(cmake/ert_module.cmake) + +add_subdirectory( script ) add_subdirectory( src ) +add_subdirectory( modules ) -#if (BUILD_APPLICATONS) -# add_subdirectory( applications ) -#endif() -#if (BUILD_TESTS) -# add_subdirectory( tests ) -#endif() +if (BUILD_APPLICATIONS) + add_subdirectory( applications ) +endif() + +if (BUILD_TESTS) + add_subdirectory( tests ) +endif() diff --git a/ThirdParty/Ert/devel/libanalysis/applications/CMakeLists.txt b/ThirdParty/Ert/devel/libanalysis/applications/CMakeLists.txt new file mode 100644 index 0000000000..e989735cf4 --- /dev/null +++ b/ThirdParty/Ert/devel/libanalysis/applications/CMakeLists.txt @@ -0,0 +1,8 @@ +add_executable( ert_module_test ert_module_test.c ) +target_link_libraries( ert_module_test analysis ert_util ) + +if (USE_RUNPATH) + add_runpath( ert_module_test ) +endif() + +install(TARGETS ert_module_test DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) diff --git a/ThirdParty/Ert/devel/libanalysis/applications/module_test.c b/ThirdParty/Ert/devel/libanalysis/applications/ert_module_test.c similarity index 91% rename from ThirdParty/Ert/devel/libanalysis/applications/module_test.c rename to ThirdParty/Ert/devel/libanalysis/applications/ert_module_test.c index 0551b67394..d773ecffa5 100644 --- a/ThirdParty/Ert/devel/libanalysis/applications/module_test.c +++ b/ThirdParty/Ert/devel/libanalysis/applications/ert_module_test.c @@ -15,20 +15,22 @@ See the GNU General Public License at for more details. */ - -#include -#include #include #include -#include +#include + +#include + +#include -void check_module( rng_type * rng , const char * lib_name ) { +int check_module( rng_type * rng , const char * lib_name ) { analysis_module_load_status_enum load_status; analysis_module_type * module = analysis_module_alloc_external__( rng , "MODULE" , lib_name , false , &load_status); if (module != NULL) { printf("Module loaded successfully\n"); analysis_module_free( module ); + return 0; } else { if (load_status == DLOPEN_FAILURE) { printf("\ndlerror(): %s\n\n",dlerror()); @@ -46,13 +48,11 @@ void check_module( rng_type * rng , const char * lib_name ) { printf("See documentation of \'symbol_table\' in modules.txt.\n\n"); } } + return 1; } int main( int argc , char ** argv) { - int iarg; - for (iarg = 1; iarg < argc; iarg++) { - check_module( NULL , argv[iarg] ); - } + exit( check_module( NULL , argv[1] ) ); } diff --git a/ThirdParty/Ert/devel/libanalysis/cmake/ert_module.cmake b/ThirdParty/Ert/devel/libanalysis/cmake/ert_module.cmake new file mode 100644 index 0000000000..0a9c5e5413 --- /dev/null +++ b/ThirdParty/Ert/devel/libanalysis/cmake/ert_module.cmake @@ -0,0 +1,21 @@ +function( ert_module module args source_files ) + + set( build_file ${CMAKE_CURRENT_BINARY_DIR}/${module}.so ) + set( depends analysis ) + set( arg_string "${module} ${args}") + separate_arguments( arg_list UNIX_COMMAND "${arg_string}") + foreach (src_file ${source_files} ) + list(APPEND arg_list ${CMAKE_CURRENT_SOURCE_DIR}/${src_file} ) + list(APPEND depends ${CMAKE_CURRENT_SOURCE_DIR}/${src_file} ) + endforeach() + + add_custom_command( + OUTPUT ${build_file} + COMMAND ${PROJECT_SOURCE_DIR}/libanalysis/script/ert_module + ARGS ${arg_list} + DEPENDS ${depends}) + + install(FILES ${build_file} DESTINATION ${CMAKE_INSTALL_LIBDIR}) + add_custom_target( ${module} ALL DEPENDS ${build_file} ) + +endfunction() diff --git a/ThirdParty/Ert/devel/libanalysis/include/ert/analysis/analysis_module.h b/ThirdParty/Ert/devel/libanalysis/include/ert/analysis/analysis_module.h index 82de8c95c3..b177e402f1 100644 --- a/ThirdParty/Ert/devel/libanalysis/include/ert/analysis/analysis_module.h +++ b/ThirdParty/Ert/devel/libanalysis/include/ert/analysis/analysis_module.h @@ -42,7 +42,7 @@ extern "C" { #define ANALYSIS_USE_A 4 // The module will read the content of A - but not modify it. #define ANALYSIS_UPDATE_A 8 // The update will be based on modifying A directly, and not on an X matrix. #define ANALYSIS_SCALE_DATA 16 - +#define ANALYSIS_ITERABLE 32 // The module can bu uused as an iterative smoother. #define EXTERNAL_MODULE_NAME "analysis_table" #define EXTERNAL_MODULE_SYMBOL analysis_table diff --git a/ThirdParty/Ert/devel/libanalysis/modules/CMakeLists.txt b/ThirdParty/Ert/devel/libanalysis/modules/CMakeLists.txt new file mode 100644 index 0000000000..c9c8accf5a --- /dev/null +++ b/ThirdParty/Ert/devel/libanalysis/modules/CMakeLists.txt @@ -0,0 +1,7 @@ +set( args "--silent --exclude-ert -I${PROJECT_SOURCE_DIR}/libanalysis/include -I${PROJECT_SOURCE_DIR}/libert_util/include -I${CMAKE_CURRENT_SOURCE_DIR} -I${PROJECT_BINARY_DIR}/libert_util/include") + +set( RML_SOURCE_FILES + rml_enkf.c + rml_enkf_common.c ) + +ert_module( rml_enkf ${args} "${RML_SOURCE_FILES}") diff --git a/ThirdParty/Ert/devel/libanalysis/src/rml_enkf.c b/ThirdParty/Ert/devel/libanalysis/modules/rml_enkf.c similarity index 96% rename from ThirdParty/Ert/devel/libanalysis/src/rml_enkf.c rename to ThirdParty/Ert/devel/libanalysis/modules/rml_enkf.c index 39a3ddd16c..f48e94aa2f 100644 --- a/ThirdParty/Ert/devel/libanalysis/src/rml_enkf.c +++ b/ThirdParty/Ert/devel/libanalysis/modules/rml_enkf.c @@ -13,11 +13,11 @@ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License at - for more details. + for more details. */ -#include -#include +#include +#include #include #include @@ -30,9 +30,10 @@ #include #include #include -#include #include +#include + /* A random 'magic' integer id which is used for run-time type checking of the input data. @@ -128,6 +129,9 @@ void rml_enkf_set_subspace_dimension( rml_enkf_data_type * data , int subspace_d data->truncation = INVALID_TRUNCATION; } +void rml_enkf_set_iteration_number( rml_enkf_data_type *data , int iteration_number ) { + data->iteration_nr = iteration_number; +} void * rml_enkf_data_alloc( rng_type * rng) { @@ -136,7 +140,7 @@ void * rml_enkf_data_alloc( rng_type * rng) { rml_enkf_set_truncation( data , DEFAULT_ENKF_TRUNCATION_ ); rml_enkf_set_subspace_dimension( data , DEFAULT_SUBSPACE_DIMENSION ); - data->option_flags = ANALYSIS_NEED_ED + ANALYSIS_UPDATE_A; + data->option_flags = ANALYSIS_NEED_ED + ANALYSIS_UPDATE_A + ANALYSIS_ITERABLE; data->iteration_nr = 0; data->Std = 0; data->Cd = NULL; @@ -296,6 +300,8 @@ bool rml_enkf_set_int( void * arg , const char * var_name , int value) { if (strcmp( var_name , ENKF_NCOMP_KEY_) == 0) rml_enkf_set_subspace_dimension( module_data , value ); + else if(strcmp( var_name , "NUM_ITER") == 0) + rml_enkf_set_iteration_number( module_data , value ); else name_recognized = false; diff --git a/ThirdParty/Ert/devel/libanalysis/src/rml_enkf_common.c b/ThirdParty/Ert/devel/libanalysis/modules/rml_enkf_common.c similarity index 98% rename from ThirdParty/Ert/devel/libanalysis/src/rml_enkf_common.c rename to ThirdParty/Ert/devel/libanalysis/modules/rml_enkf_common.c index b0d745797e..80290bb4f5 100644 --- a/ThirdParty/Ert/devel/libanalysis/src/rml_enkf_common.c +++ b/ThirdParty/Ert/devel/libanalysis/modules/rml_enkf_common.c @@ -31,10 +31,8 @@ #include #include #include -#include - - +#include /* This program contains common functions to both rml_enkf & rml_enkf_imodel*/ diff --git a/ThirdParty/Ert/devel/libanalysis/include/ert/analysis/rml_enkf_common.h b/ThirdParty/Ert/devel/libanalysis/modules/rml_enkf_common.h similarity index 100% rename from ThirdParty/Ert/devel/libanalysis/include/ert/analysis/rml_enkf_common.h rename to ThirdParty/Ert/devel/libanalysis/modules/rml_enkf_common.h diff --git a/ThirdParty/Ert/devel/libanalysis/script/CMakeLists.txt b/ThirdParty/Ert/devel/libanalysis/script/CMakeLists.txt new file mode 100644 index 0000000000..ca6ea7ea7f --- /dev/null +++ b/ThirdParty/Ert/devel/libanalysis/script/CMakeLists.txt @@ -0,0 +1 @@ +install(PROGRAMS ert_module DESTINATION ${CMAKE_INSTALL_PREFIX}/bin) diff --git a/ThirdParty/Ert/devel/libanalysis/script/ert_module b/ThirdParty/Ert/devel/libanalysis/script/ert_module new file mode 100644 index 0000000000..d0b240f0b8 --- /dev/null +++ b/ThirdParty/Ert/devel/libanalysis/script/ert_module @@ -0,0 +1,246 @@ +#!/usr/bin/env python +import sys +import os +import os.path +from optparse import OptionParser + +ert_root = os.path.realpath( os.path.join(os.path.dirname( os.path.abspath( __file__)) , "../") ) + +#----------------------------------------------------------------- + +default_lib_list = ["analysis" , "ert_util"] +default_define_list = ["HAVE_PTHREAD"] + + +CFLAGS = "-std=gnu99 -O2 -Wall -fpic -g" +LDFLAGS_list = ["-shared"] +CC = "gcc" +LD = CC + +#----------------------------------------------------------------- + + +c_file = 0 +header_file = 1 +object_file = 2 +other = 3 + +file_types = {".o" : object_file , + ".h" : header_file , + ".c" : c_file } + +def base_name(file): + (name,ext) = os.path.split( file ) + return name + + +def file_type( file ): + name,ext = os.path.splitext( file ) + return file_types.get( ext , other ) + + +def object_file_name( file ): + (name,ext) = os.path.splitext( file ) + return "%s.o" % name + + +def make_LDFLAGS( use_rpath , lib_path_list): + if use_rpath: + LDFLAGS_list.append("-Wl,--enable-new-dtags") + for path in lib_path_list: + LDFLAGS_list.append("-Wl,-rpath,%s" % path) + LDFLAGS_list.append("-Wl,-soname,") + + return " ".join(LDFLAGS_list) + + +def make_XFLAG( X , def_list ): + FLAG = "" + for d in def_list: + FLAG += "-%s%s " % (X , d) + return FLAG + + +def compile_file( file , IFLAG , DFLAG , verbose): + target = object_file_name( file ) + if os.path.exists( target ): + os.unlink( target ) + + cmd = "%s %s %s %s -c %s -o %s" % (CC , CFLAGS , IFLAG , DFLAG , file , target) + if verbose: + print "Compiling: %s" % cmd + os.system( cmd ) + if os.path.exists( target ): + return target + else: + sys.exit("Compile cmd:%s failed" % cmd) + + +def link( soname , filename , object_list , LDFLAGS , LFLAG , lFLAG , verbose): + object_string = "" + for obj in object_list: + object_string += "%s " % obj + + cmd = "%s %s%s -o %s %s %s %s" % ( LD , LDFLAGS , soname , filename , object_string , LFLAG , lFLAG) + if verbose: + print "Linking : %s" % cmd + if os.path.exists( filename ): + os.unlink( filename ) + os.system(cmd) + if os.path.exists( filename ): + return True + else: + return False + + +usage = """ +The ert_module script is a small convenience script to +compile C source code into an analysis module which can +be loaded by ert. The script is controlled by commandline +arguments: + + 1. The first argument should be the name of the module + you are creating, an extension .so will be appended. + + 2. List the source files you want to include, the + files should have extension .c. In addition you can + include object files which have been compiled by + other means, the object files should have + extension .o + + 3. Optionally you can pass -I and -D options which are + passed to the compiler; and -l and -L options which + are passed to the linker. + +Example: + + ert_module my_module my_src1.c my_src2.c f90_object1.o f90_object2.o -I/path -DFAST=Yes -L/path/to/lib -lfm -lz + +Will create a module 'my_module' based on the src files my_src1.c +and my_src2.c; in addition the object files f90_object1.o and +f90_object2.o will be included in the final module. + +----------------------------------------------------------------- + +To compile the module code you will typically need the include files +and libraries from an existing ert installation. By default the +ert_module script will locate the ert installation based on the +location of the script, but you can pass the option: + + --ert-root=/path/where/ert/is/installed + +The --ert-root option should point to a directory containing the +lib64/ and include/ directories of a binary etr distribution. In +addition to --ert-root you can use the normal -L/path/to/lib option to +send in additional link path arguments. + +By default the path to shared libraries will not be embedded in the +resulting module, but by passing the option --use-rpath you can tell +the script to embed these paths in the final shared object. + +----------------------------------------------------------------- + +Options summary: + + -L/path/to/lib: Include the path /path/to/lib in the linker path + + -llib1 : Link with the library lib1 + + -I/include : Include the path /include in the compiler include path. + + --ert-root=/path/to/ert : Use this is as root for ert headers + and libraries. [Default: inferred from location of script] + + --use-rpath : Embed library paths in shared objects. Default off. + + --exclude-ert: Do not use any ert default libraries or headers + + +Default flags: + +Compile: %s %s %s +Link: %s %s %s +""" % (CC, + make_XFLAG( "I" , ["./" , "%s/include" % ert_root]) , + make_XFLAG( "D" , default_define_list) , + LD , + make_XFLAG("L" , ["%s/lib64" % ert_root]) , + make_XFLAG("l" , default_lib_list)) + +parser = OptionParser( usage ) +parser.add_option("--ert-root" , dest="ert_root" , action="store") +parser.add_option("-I" , dest = "include_path_list", action = "append") +parser.add_option("-D" , dest = "define_list" , action = "append") +parser.add_option("-L" , dest = "lib_path_list" , action = "append") +parser.add_option("-l" , dest = "lib_list" , action = "append") +parser.add_option("--exclude-ert" , dest = "exclude_ert" , action="store_true" , default = False) +parser.add_option("--use-rpath" , dest="use_rpath" , action="store_true" , default = False) +parser.add_option("--silent" , dest="silent" , action="store_true" , default = False) + +(options , args) = parser.parse_args() +if len(args) == 0: + sys.exit( usage ) + +if options.ert_root: + ert_root = options.ert_root + +if options.exclude_ert: + include_path_list = ["./"] + lib_path_list = [] + define_list = [] + lib_list = [] +else: + include_path_list = ["./" , "%s/include" % ert_root] + lib_path_list = ["%s/lib64" % ert_root] + define_list = default_define_list + lib_list = default_lib_list + + +if options.include_path_list: + include_path_list += options.include_path_list + +if options.define_list: + define_list += options.define_list + +if options.lib_list: + lib_list += options.lib_list + +if options.lib_path_list: + lib_path_list += options.lib_path_list + + +verbose = not options.silent +LDFLAGS = make_LDFLAGS( options.use_rpath , lib_path_list) +input_name = args[0] +(path , tmp ) = os.path.split( input_name ) +(module , ext) = os.path.splitext( tmp ) + +soname = "%s.so" % module +if path: + filename = "%s/%s.so" % (path , module) + if not os.path.exists( path ): + os.makedirs( path ) +else: + filename = "%s.so" % module + +#----------------------------------------------------------------- + +IFLAG = make_XFLAG( "I" , include_path_list ) +DFLAG = make_XFLAG( "D" , define_list ) +LFLAG = make_XFLAG( "L" , lib_path_list ) +lFLAG = make_XFLAG( "l" , lib_list ) + +object_list = [] +for arg in args[1:]: + if file_type( arg ) == c_file: + object_list.append( compile_file( arg , IFLAG , DFLAG , verbose) ) + elif file_type( arg ) == object_file: + object_list.append( arg ) + else: + print "** Warning: ignoring file:%s" % arg + + +if link( soname , filename , object_list , LDFLAGS , LFLAG , lFLAG , verbose): + sys.exit() +else: + sys.exit("Creating library failed") diff --git a/ThirdParty/Ert/devel/libanalysis/src/CMakeLists.txt b/ThirdParty/Ert/devel/libanalysis/src/CMakeLists.txt index 32706738ef..c191fd8e1f 100644 --- a/ThirdParty/Ert/devel/libanalysis/src/CMakeLists.txt +++ b/ThirdParty/Ert/devel/libanalysis/src/CMakeLists.txt @@ -1,6 +1,6 @@ # Common libanalysis library set( source_files analysis_module.c enkf_linalg.c std_enkf.c sqrt_enkf.c cv_enkf.c bootstrap_enkf.c null_enkf.c fwd_step_enkf.c ) -set( header_files analysis_module.h enkf_linalg.h analysis_table.h) +set( header_files analysis_module.h enkf_linalg.h analysis_table.h std_enkf.h) add_library( analysis SHARED ${source_files} ) set_target_properties( analysis PROPERTIES COMPILE_DEFINITIONS INTERNAL_LINK) set_target_properties( analysis PROPERTIES VERSION 1.0 SOVERSION 1.0 ) @@ -14,17 +14,22 @@ if (USE_RUNPATH) add_runpath( analysis ) endif() -# List of modules -set( CMAKE_SHARED_MODULE_PREFIX "" ) -add_library( std_enkf MODULE std_enkf.c ) -add_library( sqrt_enkf MODULE sqrt_enkf.c ) -add_library( rml_enkf MODULE rml_enkf.c rml_enkf_common.c ) + +## List of modules +#set( CMAKE_SHARED_MODULE_PREFIX "" ) +##add_library( std_enkf MODULE std_enkf.c ) +#add_library( sqrt_enkf MODULE sqrt_enkf.c ) +#add_library( rml_enkf MODULE rml_enkf.c rml_enkf_common.c ) +# +#ert_module( std_enkf std_enkf.c ) + + #----------------------------------------------------------------- if (INSTALL_ERT) install(TARGETS analysis DESTINATION ${CMAKE_INSTALL_LIBDIR}) - install(TARGETS rml_enkf DESTINATION ${CMAKE_INSTALL_LIBDIR}) + #install(TARGETS rml_enkf DESTINATION ${CMAKE_INSTALL_LIBDIR}) foreach(header ${header_files}) install(FILES ../include/ert/analysis/${header} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/ert/analysis) endforeach() diff --git a/ThirdParty/Ert/devel/libanalysis/src/ert_module b/ThirdParty/Ert/devel/libanalysis/src/ert_module deleted file mode 100644 index 96fdff2176..0000000000 --- a/ThirdParty/Ert/devel/libanalysis/src/ert_module +++ /dev/null @@ -1,167 +0,0 @@ -#!/usr/bin/env python -import sys -import os -from optparse import OptionParser - -#----------------------------------------------------------------- - -lib_list = ["analysis" , "ert_util"] -lib_path_list = ["./" , "../../libutil/slib"] -include_path_list = ["../include" , "../../libutil/src"] -define_list = ["HAVE_PTHREAD"] - - -CFLAGS = "-std=gnu99 -O2 -Wall -fpic -g" -LDFLAGS = "-shared -Wl,-soname," -CC = "gcc" -LD = CC - - -#----------------------------------------------------------------- - -c_file = 0 -header_file = 1 -object_file = 2 -other = 3 - -file_types = {".o" : object_file , - ".h" : header_file , - ".c" : c_file } - -def base_name(file): - (name,ext) = os.path.split( file ) - return name - - -def file_type( file ): - name,ext = os.path.splitext( file ) - return file_types.get( ext , other ) - - -def object_file_name( file ): - (name,ext) = os.path.splitext( file ) - return "%s.o" % name - - -def make_XFLAG( X , def_list ): - FLAG = "" - for d in def_list: - FLAG += "-%s%s " % (X , d) - return FLAG - - -def compile_file( file , IFLAG , DFLAG ): - target = object_file_name( file ) - if os.path.exists( target ): - os.unlink( target ) - - cmd = "%s %s %s %s -c %s -o %s" % (CC , CFLAGS , IFLAG , DFLAG , file , target) - print "Compiling: %s" % cmd - os.system( cmd ) - if os.path.exists( target ): - return target - else: - sys.exit("Compile cmd:%s failed" % cmd) - - -def link( libname , object_list , LFLAG , lFLAG): - (tmp,ext) = os.path.splitext( libname ) - if not ext: - libname += ".so" - - object_string = "" - for obj in object_list: - object_string += "%s " % obj - soname = libname - cmd = "%s %s%s -o %s %s %s %s" % ( LD , LDFLAGS , soname , libname , object_string , LFLAG , lFLAG) - print "Linking : %s" % cmd - if os.path.exists( libname ): - os.unlink( libname ) - os.system(cmd) - if os.path.exists( libname ): - - return True - else: - return False - - -usage = """ -The ert_module script is a small convenience script to -compile C source code into an analysis module which can -be loaded by ert. The script is controlled by commandline -arguments: - - 1. The first argument should be the name of the module - you are creating, an extension .so will be appended. - - 2. List the source files you want to include, the - files should have extension .c. In addition you can - include object files which have been compiled by - other means, the object files should have - extension .o - - 3. Optionally you can pass -I and -D options which are - passed to the compiler; and -l and -L options which - are passed to the linker. - -Example: - - ert_module my_module my_src1.c my_src2.c f90_object1.o f90_object2.o -I/path -DFAST=Yes -L/path/to/lib -lfm -lz - -Will create a module 'my_module' based on the src files my_src1.c -and my_src2.c; in addition the object files f90_object1.o and -f90_object2.o will be included in the final module. - -By default the ert_module script will include some libraries from the -core ert distribution; if you are not interested in referencing these -you can issue the option --exclude-ert. Default flags: - -Compile: %s %s -Link: %s %s -""" % (make_XFLAG( "I" , include_path_list) , make_XFLAG( "D" , define_list) , make_XFLAG("L" , lib_path_list) , make_XFLAG("l" , lib_list)) - -parser = OptionParser( usage ) -parser.add_option("-I" , dest = "include_path_list", action = "append") -parser.add_option("-D" , dest = "define_list" , action = "append") -parser.add_option("-L" , dest = "lib_path_list" , action = "append") -parser.add_option("-l" , dest = "lib_list" , action = "append") -parser.add_option("--exclude-ert" , dest = "exclude_ert" , action="store_true" , default = False) - -(options , args) = parser.parse_args() -if len(args) == 0: - sys.exit( usage ) - -if options.exclude_ert: - include_path_list = [] - define_list = [] - lib_list = [] - lib_path_list = [] - - -if options.include_path_list: - include_path_list += options.include_path_list - -if options.define_list: - define_list += options.define_list - -if options.lib_list: - lib_list += options.lib_list - -if options.lib_path_list: - lib_path_list += options.lib_path_list - -IFLAG = make_XFLAG( "I" , include_path_list ) -DFLAG = make_XFLAG( "D" , define_list ) -LFLAG = make_XFLAG( "L" , lib_path_list ) -lFLAG = make_XFLAG( "l" , lib_list ) - -object_list = [] -for arg in args[1:]: - if file_type( arg ) == c_file: - object_list.append( compile_file( arg ,IFLAG , DFLAG) ) - elif file_type( arg ) == object_file: - object_list.append( arg ) - else: - print "** Warning: ignoring file:%s" % arg - -link( args[0] , object_list , LFLAG , lFLAG) diff --git a/ThirdParty/Ert/devel/libanalysis/tests/CMakeLists.txt b/ThirdParty/Ert/devel/libanalysis/tests/CMakeLists.txt new file mode 100644 index 0000000000..6f1e600b95 --- /dev/null +++ b/ThirdParty/Ert/devel/libanalysis/tests/CMakeLists.txt @@ -0,0 +1 @@ +add_test( analysis_rml_enkf_module ${EXECUTABLE_OUTPUT_PATH}/ert_module_test ${PROJECT_BINARY_DIR}/libanalysis/modules/rml_enkf.so ) diff --git a/ThirdParty/Ert/devel/libecl/include/ert/ecl/nnc_vector.h b/ThirdParty/Ert/devel/libecl/include/ert/ecl/nnc_vector.h index bd4ac59de1..3aa6c629a9 100644 --- a/ThirdParty/Ert/devel/libecl/include/ert/ecl/nnc_vector.h +++ b/ThirdParty/Ert/devel/libecl/include/ert/ecl/nnc_vector.h @@ -33,7 +33,7 @@ extern "C" { nnc_vector_type * nnc_vector_alloc(int lgr_nr); void nnc_vector_free( nnc_vector_type * nnc_vector ); void nnc_vector_add_nnc(nnc_vector_type * nnc_vector, int global_cell_number); - const int_vector_type * nnc_vector_get_index_list(const nnc_vector_type * nnc_vector); + const int_vector_type * nnc_vector_get_index_list(nnc_vector_type * nnc_vector); int nnc_vector_get_lgr_nr(const nnc_vector_type * nnc_vector ); void nnc_vector_free__(void * arg); diff --git a/ThirdParty/Ert/devel/libecl/src/ecl_grid.c b/ThirdParty/Ert/devel/libecl/src/ecl_grid.c index b9613ea387..0bb505218b 100644 --- a/ThirdParty/Ert/devel/libecl/src/ecl_grid.c +++ b/ThirdParty/Ert/devel/libecl/src/ecl_grid.c @@ -2133,7 +2133,7 @@ static void ecl_grid_init_nnc_cells( ecl_grid_type * grid1, ecl_grid_type * grid ecl_cell_type * grid1_cell = ecl_grid_get_cell(grid1, grid1_cell_index); ecl_cell_type * grid2_cell = ecl_grid_get_cell(grid2, grid2_cell_index); - //Add the non-neighbour connection in both directions + //Add the non-neighbour connection in both directions nnc_info_add_nnc(grid1_cell->nnc_info, grid2->lgr_nr, grid2_cell_index); nnc_info_add_nnc(grid2_cell->nnc_info, grid1->lgr_nr, grid1_cell_index); @@ -2149,28 +2149,35 @@ static void ecl_grid_init_nnc_cells( ecl_grid_type * grid1, ecl_grid_type * grid */ static void ecl_grid_init_nnc(ecl_grid_type * main_grid, ecl_file_type * ecl_file) { int num_nnchead_kw = ecl_file_get_num_named_kw( ecl_file , NNCHEAD_KW ); - int num_nncg_kw = ecl_file_get_num_named_kw( ecl_file , NNCG_KW ); int i; for (i = 0; i < num_nnchead_kw; i++) { - ecl_kw_type * nnchead_kw = ecl_file_iget_named_kw( ecl_file , NNCHEAD_KW , i); - int lgr_nr = ecl_kw_iget_int(nnchead_kw, NNCHEAD_LGR_INDEX); - ecl_kw_type * keyword1 = NULL; - ecl_kw_type * keyword2 = NULL; - - if (ECL_GRID_MAINGRID_LGR_NR == lgr_nr) { - keyword1 = ecl_file_iget_named_kw( ecl_file , NNC1_KW , i); - keyword2 = ecl_file_iget_named_kw( ecl_file , NNC2_KW , i); - } else { - int nnc_lgr_index = (num_nnchead_kw == num_nncg_kw) ? i : i-1; //Subtract 1 if no nnc data for main grid - keyword1 = ecl_file_iget_named_kw( ecl_file , NNCL_KW , nnc_lgr_index); - keyword2 = ecl_file_iget_named_kw( ecl_file , NNCG_KW , nnc_lgr_index); - } - + ecl_file_push_block(ecl_file); /* <---------------------------------------------------------------- */ + ecl_file_select_block(ecl_file , NNCHEAD_KW , i); { - ecl_grid_type * grid = (lgr_nr > 0) ? ecl_grid_get_lgr_from_lgr_nr(main_grid, lgr_nr) : main_grid; - ecl_grid_init_nnc_cells(grid, main_grid, keyword1, keyword2); + ecl_kw_type * nnchead_kw = ecl_file_iget_named_kw(ecl_file, NNCHEAD_KW, 0); + int lgr_nr = ecl_kw_iget_int(nnchead_kw, NNCHEAD_LGR_INDEX); + + if (ecl_file_has_kw(ecl_file , NNC1_KW)) { + const ecl_kw_type * nnc1 = ecl_file_iget_named_kw(ecl_file, NNC1_KW, 0); + const ecl_kw_type * nnc2 = ecl_file_iget_named_kw(ecl_file, NNC2_KW, 0); + + { + ecl_grid_type * grid = (lgr_nr > 0) ? ecl_grid_get_lgr_from_lgr_nr(main_grid, lgr_nr) : main_grid; + ecl_grid_init_nnc_cells(grid, grid, nnc1, nnc2); + } + } + + if (ecl_file_has_kw(ecl_file , NNCL_KW)) { + const ecl_kw_type * nncl = ecl_file_iget_named_kw(ecl_file, NNCL_KW, 0); + const ecl_kw_type * nncg = ecl_file_iget_named_kw(ecl_file, NNCG_KW, 0); + { + ecl_grid_type * grid = (lgr_nr > 0) ? ecl_grid_get_lgr_from_lgr_nr(main_grid, lgr_nr) : main_grid; + ecl_grid_init_nnc_cells(grid, main_grid, nncl, nncg); + } + } } + ecl_file_pop_block( ecl_file ); /* <------------------------------------------------------------------ */ } } diff --git a/ThirdParty/Ert/devel/libecl/src/fortio.c b/ThirdParty/Ert/devel/libecl/src/fortio.c index fd27c6ca71..401e393dd7 100644 --- a/ThirdParty/Ert/devel/libecl/src/fortio.c +++ b/ThirdParty/Ert/devel/libecl/src/fortio.c @@ -422,7 +422,6 @@ void fortio_fclose(fortio_type *fortio) { bool fortio_is_fortio_file(fortio_type * fortio) { - FILE * stream = fortio->stream; offset_type init_pos = fortio_ftell(fortio); int elm_read; bool is_fortio_file = false; diff --git a/ThirdParty/Ert/devel/libecl/src/nnc_vector.c b/ThirdParty/Ert/devel/libecl/src/nnc_vector.c index 921ada21ab..50d6ce4892 100644 --- a/ThirdParty/Ert/devel/libecl/src/nnc_vector.c +++ b/ThirdParty/Ert/devel/libecl/src/nnc_vector.c @@ -24,6 +24,7 @@ #include #include +#include #define NNC_VECTOR_TYPE_ID 875615078 @@ -31,8 +32,8 @@ struct nnc_vector_struct { UTIL_TYPE_ID_DECLARATION; - int_vector_type *nnc_index_list; - int lgr_nr; + nnc_index_list_type * index_list; + int lgr_nr; }; @@ -44,13 +45,13 @@ static UTIL_SAFE_CAST_FUNCTION(nnc_vector , NNC_VECTOR_TYPE_ID) nnc_vector_type * nnc_vector_alloc(int lgr_nr) { nnc_vector_type * nnc_vector = util_malloc( sizeof * nnc_vector ); UTIL_TYPE_ID_INIT(nnc_vector , NNC_VECTOR_TYPE_ID); - nnc_vector->nnc_index_list = int_vector_alloc(0, 0); + nnc_vector->index_list = nnc_index_list_alloc(); nnc_vector->lgr_nr = lgr_nr; return nnc_vector; } void nnc_vector_free( nnc_vector_type * nnc_vector ) { - int_vector_free( nnc_vector->nnc_index_list ); + nnc_index_list_free( nnc_vector->index_list ); free( nnc_vector ); } @@ -62,12 +63,12 @@ void nnc_vector_free__(void * arg) { void nnc_vector_add_nnc(nnc_vector_type * nnc_vector, int global_cell_number) { - int_vector_append( nnc_vector->nnc_index_list , global_cell_number ); + nnc_index_list_add_index( nnc_vector->index_list , global_cell_number ); } -const int_vector_type * nnc_vector_get_index_list(const nnc_vector_type * nnc_vector) { - return nnc_vector->nnc_index_list; +const int_vector_type * nnc_vector_get_index_list(nnc_vector_type * nnc_vector) { + return nnc_index_list_get_list(nnc_vector->index_list); } diff --git a/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_amalgamated.c b/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_amalgamated.c new file mode 100644 index 0000000000..9a072b6779 --- /dev/null +++ b/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_amalgamated.c @@ -0,0 +1,34 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'ecl_nnc_index_list_grid.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#include +#include + +#include +#include +#include + +#include +#include +#include + + + +int main( int argc , char ** argv) { + ecl_grid_type * ecl_grid = ecl_grid_alloc( argv[1] ); + exit(0); +} diff --git a/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_test.c b/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_test.c index ed8d8e53aa..9d25a9abc1 100644 --- a/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_test.c +++ b/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_test.c @@ -65,11 +65,13 @@ void test_nnc_lgr( const char * grid_filename ) { const int_vector_type * nnc_cell_number_vec = nnc_info_get_index_list(nnc_info, 0); test_assert_not_NULL(nnc_cell_number_vec); + int_vector_fprintf(nnc_cell_number_vec , stdout , "nnc_cell_number" , "%6d"); + test_assert_int_equal(int_vector_size(nnc_cell_number_vec), 1); test_assert_int_equal(int_vector_iget(nnc_cell_number_vec, 0), 151053); //LGR - const int data[] = {126394, 126305}; + const int data[] = {126305, 126394}; ecl_grid_type * lgr_grid = ecl_grid_iget_lgr(ecl_grid, 0); test_assert_not_NULL( lgr_grid ); @@ -85,7 +87,7 @@ void test_nnc_lgr( const char * grid_filename ) { int i; for (i = 0; i < int_vector_size(lgr_nnc_cell_number_vec); i++) - test_assert_int_equal(int_vector_iget(lgr_nnc_cell_number_vec, i), data[i]); + test_assert_int_equal(data[i], int_vector_iget(lgr_nnc_cell_number_vec, i)); ecl_grid_free(ecl_grid); } @@ -98,7 +100,7 @@ void test_nnc_multiple_lgr( const char * grid_filename) { { //Global grid, check NNC for cell with global index 736 - int data[] = {11957, 20336, 3528, 6321, 9114, 11907, 20286}; + int data[] = {3528, 6321, 9114, 11907, 11957, 20286 , 20336}; const nnc_info_type * nnc_info = ecl_grid_get_cell_nnc_info1(ecl_grid, 736); test_assert_not_NULL(nnc_info); @@ -120,7 +122,7 @@ void test_nnc_multiple_lgr( const char * grid_filename) { { //Global grid, check NNC for cell with global index 138291 - int data[] = {141035, 143828, 141085, 143878}; + int data[] = {141035, 141085, 143828, 143878}; const nnc_info_type * nnc_info = ecl_grid_get_cell_nnc_info1(ecl_grid, 138291); test_assert_not_NULL(nnc_info); @@ -138,7 +140,7 @@ void test_nnc_multiple_lgr( const char * grid_filename) { { //LGR nr 1, cell global index 0: check NNCs to main grid - int data[] = {29012, 26220}; + int data[] = {26220 , 29012}; ecl_grid_type * lgr_grid = ecl_grid_iget_lgr(ecl_grid, 0); test_assert_not_NULL(lgr_grid); @@ -211,7 +213,7 @@ void test_nnc_multiple_lgr( const char * grid_filename) { { //LGR nr 99, check NNC for cell with global index 736 - int data[] = {126671, 79142}; + int data[] = {79142 ,126671}; ecl_grid_type * lgr_grid = ecl_grid_iget_lgr(ecl_grid, 98-1); //Subtract 1: LGR nr 98 is not present in the test file. LGRs are numbered 1-97 and 99-110 in test file. test_assert_not_NULL(lgr_grid); @@ -333,7 +335,7 @@ int main(int argc , char ** argv) { test_nnc_global_grid( EGRID_file1 ); test_nnc_lgr( EGRID_file2 ); - test_nnc_multiple_lgr( EGRID_file3 ); + test_nnc_multiple_lgr( EGRID_file3 ); test_nnc_amalgamated_lgrs(EGRID_file3); test_nnc_dual_poro( EGRID_file4 ); diff --git a/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_vector.c b/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_vector.c index d12cbeda03..2746b050e9 100644 --- a/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_vector.c +++ b/ThirdParty/Ert/devel/libecl/tests/ecl_nnc_vector.c @@ -35,6 +35,11 @@ int main(int argc , char ** argv) { nnc_vector_add_nnc( vector , 200 ); nnc_vector_add_nnc( vector , 300 ); + nnc_vector_add_nnc( vector , 100 ); + nnc_vector_add_nnc( vector , 200 ); + nnc_vector_add_nnc( vector , 300 ); + + { const int_vector_type * index_list = nnc_vector_get_index_list( vector ); diff --git a/ThirdParty/Ert/devel/libecl/tests/tests.cmake b/ThirdParty/Ert/devel/libecl/tests/tests.cmake index d122914436..8dca1a923b 100644 --- a/ThirdParty/Ert/devel/libecl/tests/tests.cmake +++ b/ThirdParty/Ert/devel/libecl/tests/tests.cmake @@ -2,6 +2,9 @@ add_executable( ecl_coarse_test ecl_coarse_test.c ) target_link_libraries( ecl_coarse_test ecl test_util ) add_test( ecl_coarse_test ${EXECUTABLE_OUTPUT_PATH}/ecl_coarse_test ${PROJECT_SOURCE_DIR}/test-data/Statoil/ECLIPSE/LGCcase/LGC_TESTCASE2 ) +add_executable( ecl_nnc_amalgamated ecl_nnc_amalgamated.c ) +target_link_libraries( ecl_nnc_amalgamated ecl test_util ) +add_test( ecl_nnc_amalgamated ${EXECUTABLE_OUTPUT_PATH}/ecl_nnc_amalgamated ${PROJECT_SOURCE_DIR}/test-data/Statoil/ECLIPSE/nestedLGRcase/TESTCASE_NESTEDLGR.EGRID ) add_executable( ecl_restart_test ecl_restart_test.c ) target_link_libraries( ecl_restart_test ecl test_util ) @@ -61,6 +64,14 @@ target_link_libraries( ecl_nnc_info_test ecl test_util ) add_test (ecl_nnc_info_test ${EXECUTABLE_OUTPUT_PATH}/ecl_nnc_info_test ) +add_executable( ecl_nnc_vector ecl_nnc_vector.c ) +target_link_libraries( ecl_nnc_vector ecl test_util ) +add_test(ecl_nnc_vector ${EXECUTABLE_OUTPUT_PATH}/ecl_nnc_vector ) + +add_executable( ecl_nnc_index_list ecl_nnc_index_list.c ) +target_link_libraries( ecl_nnc_index_list ecl test_util ) +add_test (ecl_nnc_index_list ${EXECUTABLE_OUTPUT_PATH}/ecl_nnc_index_list ) + add_executable( ecl_kw_grdecl ecl_kw_grdecl.c ) target_link_libraries( ecl_kw_grdecl ecl test_util ) add_test( ecl_kw_grdecl ${EXECUTABLE_OUTPUT_PATH}/ecl_kw_grdecl ) @@ -173,3 +184,4 @@ set_property( TEST ecl_region2region PROPERTY LABELS StatoilData) set_property( TEST ecl_grid_case PROPERTY LABELS StatoilData) set_property( TEST ecl_rft_rft PROPERTY LABELS StatoilData) set_property( TEST ecl_rft_plt PROPERTY LABELS StatoilData) +set_property( TEST ecl_nnc_amalgamated PROPERTY LABELS StatoilData) diff --git a/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_QC.c b/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_QC.c index d4299e9d56..aa86d333e2 100644 --- a/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_QC.c +++ b/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_QC.c @@ -24,6 +24,7 @@ #include #include +#include #include #include #include @@ -31,6 +32,7 @@ #include #include #include +#include #include #include @@ -62,12 +64,18 @@ void enkf_tui_QC_plot_get_PC( enkf_main_type * enkf_main , int step1 , int step2 double truncation , int ncomp , matrix_type * PC , matrix_type * PC_obs) { - int ens_size = enkf_main_get_ensemble_size( enkf_main ); + bool_vector_type * ens_mask = bool_vector_alloc(0 , false); obs_data_type * obs_data = obs_data_alloc(); - meas_data_type * meas_data = meas_data_alloc( ens_size ); analysis_config_type * analysis_config = enkf_main_get_analysis_config( enkf_main ); int_vector_type * step_list = int_vector_alloc(0,0); + enkf_fs_type * source_fs = enkf_main_get_fs( enkf_main); + state_map_type * state_map = enkf_fs_get_state_map(source_fs); + int_vector_type * ens_active_list; + meas_data_type * meas_data; + state_map_select_matching(state_map , ens_mask , STATE_HAS_DATA); + ens_active_list = bool_vector_alloc_active_list(ens_mask); + meas_data = meas_data_alloc(ens_active_list); { for (int step =step1; step <= step2; step++) int_vector_append( step_list , step ); @@ -81,10 +89,10 @@ void enkf_tui_QC_plot_get_PC( enkf_main_type * enkf_main , int step1 , int step2 double alpha = analysis_config_get_alpha( analysis_config ); enkf_obs_get_obs_and_measure(enkf_main_get_obs( enkf_main ), - enkf_main_get_fs( enkf_main ), + source_fs , step_list , state, - ens_size, + ens_active_list , (const enkf_state_type **) enkf_main_get_ensemble( enkf_main ), meas_data , obs_data , @@ -105,6 +113,7 @@ void enkf_tui_QC_plot_get_PC( enkf_main_type * enkf_main , int step1 , int step2 matrix_free( dObs ); } + bool_vector_free(ens_mask); int_vector_free( step_list ); obs_data_free( obs_data ); meas_data_free( meas_data ); diff --git a/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_run.c b/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_run.c index 5985108836..7a551ed766 100644 --- a/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_run.c +++ b/ThirdParty/Ert/devel/libenkf/applications/ert_tui/enkf_tui_run.c @@ -35,8 +35,6 @@ #include #include #include -#include -#include #include #include @@ -116,76 +114,29 @@ void enkf_tui_run_smoother(void * arg) { -void enkf_tui_run_iterated_ES(void * enkf_main) { - const int ens_size = enkf_main_get_ensemble_size( enkf_main ); +void enkf_tui_run_iterated_ES(void * arg) { + enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); + const ecl_config_type * ecl_config = enkf_main_get_ecl_config( enkf_main ); const int last_report = enkf_main_get_history_length( enkf_main ); - - { - model_config_type * model_config = enkf_main_get_model_config( enkf_main ); - const ecl_config_type * ecl_config = enkf_main_get_ecl_config( enkf_main ); - const analysis_config_type * analysis_config = enkf_main_get_analysis_config( enkf_main ); - analysis_iter_config_type * iter_config = analysis_config_get_iter_config( analysis_config ); - int step1 = 0; - int step2 ; - int_vector_type * step_list = int_vector_alloc(0,0); - bool_vector_type * iactive = bool_vector_alloc(0 , true); - int iter = 0; - int num_iter = analysis_iter_config_get_num_iterations( iter_config ); - stringlist_type * node_list = ensemble_config_alloc_keylist_from_var_type( enkf_main_get_ensemble_config(enkf_main) , PARAMETER ); - - if (ecl_config_has_schedule( ecl_config )) - step2 = util_scanf_int_with_limits("Last report",PROMPT_LEN , 0 , last_report); - else - step2 = last_report; - - { - for (int step=step1; step <= step2; step++) - int_vector_append( step_list , step ); - } - bool_vector_iset( iactive , ens_size - 1 , true ); - - while (true) { - { - const char * runpath_fmt = analysis_iter_config_iget_runpath_fmt( iter_config , iter); - if (runpath_fmt != NULL) { - char * runpath_key = util_alloc_sprintf( "runpath-%d" , iter); - model_config_add_runpath( model_config , runpath_key , runpath_fmt); - model_config_select_runpath( model_config , runpath_key ); - free( runpath_key ); - } - } - - enkf_main_run_exp(enkf_main , iactive , true , step1 , step1 , FORECAST); - { - const char * target_fs_name = analysis_iter_config_iget_case( iter_config , iter ); - enkf_fs_type * target_fs = enkf_main_get_alt_fs(enkf_main , target_fs_name , false , true ); - enkf_main_smoother_update(enkf_main , step_list , target_fs); - - enkf_main_copy_ensemble( enkf_main , - enkf_main_get_current_fs( enkf_main ), - 0 , // Smoother update will write on step 0 - ANALYZED , - target_fs_name , - step1 , - FORECAST , - iactive , - NULL , - node_list ); - - - enkf_main_set_fs(enkf_main , target_fs , enkf_fs_get_case_name( target_fs )); - } - //iter = analysis_module_get_int(module, "ITER"); - iter++; - if (iter == num_iter) - break; - } - int_vector_free( step_list ); - bool_vector_free( iactive ); - } - + int step2; + if (ecl_config_has_schedule( ecl_config )) + step2 = util_scanf_int_with_limits("Last report",PROMPT_LEN , 0 , last_report); + else + step2 = last_report; + enkf_main_run_iterated_ES(enkf_main, step2); } +void enkf_tui_run_one_more_iteration(void * arg){ + enkf_main_type * enkf_main = enkf_main_safe_cast( arg ); + const ecl_config_type * ecl_config = enkf_main_get_ecl_config( enkf_main ); + const int last_report = enkf_main_get_history_length( enkf_main ); + int step2; + if (ecl_config_has_schedule( ecl_config )) + step2 = util_scanf_int_with_limits("Last report",PROMPT_LEN , 0 , last_report); + else + step2 = last_report; + enkf_main_run_one_more_iteration(enkf_main, step2); +} @@ -221,7 +172,7 @@ void enkf_tui_run_exp(void * enkf_main) { free( prompt ); } if (bool_vector_count_equal(iactive , true)) - enkf_main_run_exp(enkf_main , iactive , true , init_step_parameters , start_report , init_state); + enkf_main_run_exp(enkf_main , iactive , true , init_step_parameters , start_report , init_state, true); bool_vector_free(iactive); } @@ -247,7 +198,7 @@ void enkf_tui_run_create_runpath__(void * __enkf_main) { util_safe_free( select_string ); free( prompt ); } - enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state); + enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state, true); bool_vector_free(iactive); } @@ -372,11 +323,15 @@ void enkf_tui_run_menu(void * arg) { menu_item_type * restart_enkf_item = menu_add_item(menu , "Restart EnKF run from arbitrary state" , "rR" , enkf_tui_run_restart__ , enkf_main , NULL); menu_item_type * ES_item = menu_add_item(menu , "Integrated smoother update" , "iI" , enkf_tui_run_smoother , enkf_main , NULL); menu_item_type * it_ES_item = menu_add_item(menu , "Iterated smoother [RML-EnKF]" , "tT" , enkf_tui_run_iterated_ES , enkf_main , NULL); + menu_item_type * one_more_item = menu_add_item(menu , "One more iteration" , "mM" , enkf_tui_run_one_more_iteration , enkf_main , NULL); if (!ecl_config_has_schedule( ecl_config )) { menu_item_disable( enkf_item ); menu_item_disable( restart_enkf_item ); } + + if (!ecl_config_has_init_section( ecl_config )) + menu_item_disable( enkf_item ); if (!model_config_has_history( model_config )) { menu_item_disable( it_ES_item ); diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_config.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_config.h index 1ece2b5665..f5d4b2846a 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_config.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_config.h @@ -49,7 +49,7 @@ void analysis_config_reload_module( analysis_config_type * con stringlist_type * analysis_config_alloc_module_names( analysis_config_type * config ); const char * analysis_config_get_log_path( const analysis_config_type * config ); void analysis_config_init( analysis_config_type * analysis , const config_type * config); -analysis_config_type * analysis_config_alloc_default( rng_type * rng ); +analysis_config_type * analysis_config_alloc( rng_type * rng ); void analysis_config_free( analysis_config_type * ); bool analysis_config_get_merge_observations(const analysis_config_type * ); double analysis_config_get_alpha(const analysis_config_type * config); @@ -96,6 +96,12 @@ void analysis_config_set_PC_filename( analysis_config_type * c const char * analysis_config_get_PC_filename( const analysis_config_type * config ); void analysis_config_set_PC_path( analysis_config_type * config , const char * path ); const char * analysis_config_get_PC_path( const analysis_config_type * config ); + void analysis_config_set_min_realisations( analysis_config_type * config , int min_realisations); + int analysis_config_get_min_realisations( const analysis_config_type * config ); + bool analysis_config_have_enough_realisations( const analysis_config_type * config , int realisations); + + + UTIL_IS_INSTANCE_HEADER( analysis_config ); #ifdef __cplusplus } diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_iter_config.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_iter_config.h index 27541c6b01..74988d2274 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_iter_config.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/analysis_iter_config.h @@ -28,6 +28,8 @@ typedef struct analysis_iter_config_struct analysis_iter_config_type; void analysis_iter_config_set_num_iterations( analysis_iter_config_type * config , int num_iterations); int analysis_iter_config_get_num_iterations( const analysis_iter_config_type * config ); + void analysis_iter_config_set_case_fmt( analysis_iter_config_type * config, const char * case_fmt); + char * analysis_iter_config_get_case_fmt( analysis_iter_config_type * config); analysis_iter_config_type * analysis_iter_config_alloc(); void analysis_iter_config_free( analysis_iter_config_type * config ); const char * analysis_iter_config_iget_case( analysis_iter_config_type * config , int iter); diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/cases_config.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/cases_config.h new file mode 100644 index 0000000000..b90cc84efd --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/cases_config.h @@ -0,0 +1,39 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'cases_config.h' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ + +#ifndef __CASES_CONFIG_H__ +#define __CASES_CONFIG_H__ + +#ifdef __cplusplus +extern "C" { +#endif + + +typedef struct cases_config_struct cases_config_type; + + bool cases_config_set_int( cases_config_type * config , const char * var_name, int num_iterations); + int cases_config_get_iteration_number( const cases_config_type * config ); + void cases_config_fwrite( cases_config_type * config , const char * filename ); + void cases_config_fread( cases_config_type * config , const char * filename); + cases_config_type * cases_config_alloc(); + void cases_config_free( cases_config_type * config ); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/config_keys.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/config_keys.h index 9386cc114e..0b853ff007 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/config_keys.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/config_keys.h @@ -112,6 +112,7 @@ extern "C" { #define MAX_RUNNING_RSH_KEY "MAX_RUNNING_RSH" #define MAX_SUBMIT_KEY "MAX_SUBMIT" #define NUM_REALIZATIONS_KEY "NUM_REALIZATIONS" +#define MIN_REALIZATIONS_KEY "MIN_REALIZATIONS" #define OBS_CONFIG_KEY "OBS_CONFIG" #define OBS_CONFIG_KEY "OBS_CONFIG" #define PLOT_DRIVER_KEY "PLOT_DRIVER" diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/ecl_config.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/ecl_config.h index de3c1d08bb..153e2473de 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/ecl_config.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/ecl_config.h @@ -83,6 +83,7 @@ extern "C" { void ecl_config_fprintf_config( const ecl_config_type * ecl_config , FILE * stream ); ecl_config_type * ecl_config_alloc_empty( ); void ecl_config_add_config_items( config_type * config ); + bool ecl_config_has_init_section( const ecl_config_type * ecl_config ); #ifdef __cplusplus } diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_defaults.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_defaults.h index 3b758cbd09..1449f3b376 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_defaults.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_defaults.h @@ -116,7 +116,10 @@ #define DEFAULT_UPDATE_RESULTS false #define DEFAULT_SINGLE_NODE_UPDATE true #define DEFAULT_ANALYSIS_MODULE "STD_ENKF" -#define DEFAULT_ANALYSIS_NUM_ITERATIONS 1 +#define DEFAULT_ANALYSIS_NUM_ITERATIONS 4 +#define DEFAULT_ANALYSIS_ITER_CASE "ITERATED_ENSEMBLE_SMOOTHER%d" +#define DEFAULT_ANALYSIS_ITER_RUNPATH "Simulations/Real%d" +#define DEFAULT_ANALYSIS_MIN_REALISATIONS 0 // 0: No lower limit /* Default directories. */ #define DEFAULT_QC_PATH "QC" diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_fs.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_fs.h index 690e15cce9..7bd902f8e8 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_fs.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_fs.h @@ -34,6 +34,8 @@ extern "C" { #include #include #include +#include +#include #include const char * enkf_fs_get_mount_point( const enkf_fs_type * fs ); @@ -92,8 +94,10 @@ extern "C" { FILE * enkf_fs_open_excase_file( const enkf_fs_type * fs , const char * input_name); FILE * enkf_fs_open_excase_tstep_file( const enkf_fs_type * fs , const char * input_name , int tstep ); FILE * enkf_fs_open_excase_member_file( const enkf_fs_type * fs , const char * input_name , int iens ); - + + state_map_type * enkf_fs_get_state_map( const enkf_fs_type * fs ); time_map_type * enkf_fs_get_time_map( const enkf_fs_type * fs ); + cases_config_type * enkf_fs_get_cases_config( const enkf_fs_type * fs); misfit_ensemble_type * enkf_fs_get_misfit_ensemble( const enkf_fs_type * fs ); UTIL_SAFE_CAST_HEADER( enkf_fs ); diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_main.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_main.h index 81708ac754..33135000c0 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_main.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_main.h @@ -110,24 +110,26 @@ extern "C" { void enkf_main_iload_ecl_mt(enkf_main_type *enkf_main , int ); void enkf_main_assimilation_update(enkf_main_type * enkf_main , const int_vector_type * step_list); - void enkf_main_smoother_update(enkf_main_type * enkf_main , const int_vector_type * step_list , enkf_fs_type * target_fs); + bool enkf_main_smoother_update(enkf_main_type * enkf_main , const int_vector_type * step_list , enkf_fs_type * target_fs); void enkf_main_run_exp(enkf_main_type * enkf_main , - const bool_vector_type * iactive , + bool_vector_type * iactive , bool simulate , int init_step_parameters , int start_report , - state_enum start_state); + state_enum start_state , + bool initialize); void enkf_main_run_assimilation(enkf_main_type * enkf_main , - const bool_vector_type * iactive , + bool_vector_type * iactive , int init_step_parameters , int start_report , state_enum start_state); - void enkf_main_run_smoother(enkf_main_type * enkf_main , const char * target_fs_name , bool rerun); - + void enkf_main_run_smoother(enkf_main_type * enkf_main , const char * target_fs_name , bool rerun); + void enkf_main_run_iterated_ES(enkf_main_type * enkf_main, int last_report); + void enkf_main_run_one_more_iteration(enkf_main_type * enkf_main, int step2); void enkf_main_set_data_kw(enkf_main_type * , const char * , const char *); void enkf_main_set_state_run_path(const enkf_main_type * , int ); void enkf_main_set_state_eclbase(const enkf_main_type * , int ); diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_obs.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_obs.h index dd5265664e..866898254a 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_obs.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_obs.h @@ -25,6 +25,7 @@ extern "C" { #include #include +#include #include @@ -63,7 +64,7 @@ extern "C" { enkf_fs_type * fs, const int_vector_type * step_list , state_enum state, - int ens_size, + const int_vector_type * ens_active_list, const enkf_state_type ** ensemble , meas_data_type * meas_data, obs_data_type * obs_data, diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_state.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_state.h index af60b86abd..a59bd451e4 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_state.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_state.h @@ -80,15 +80,15 @@ typedef struct enkf_state_struct enkf_state_type; void * enkf_state_run_eclipse__(void * ); void * enkf_state_start_forward_model__(void * ); - void enkf_state_load_from_forward_model(enkf_state_type * enkf_state , + void enkf_state_load_from_forward_model(enkf_state_type * enkf_state , enkf_fs_type * fs , - bool * loadOK , + int * result , bool interactive , stringlist_type * msg_list); void enkf_state_forward_init(enkf_state_type * enkf_state , enkf_fs_type * fs , - bool * loadOK ); + int * result ); enkf_state_type * enkf_state_alloc(int , rng_type * main_rng , @@ -125,7 +125,7 @@ typedef struct enkf_state_struct enkf_state_type; rng_type * enkf_state_get_rng( const enkf_state_type * enkf_state ); unsigned int enkf_state_get_random( enkf_state_type * enkf_state ); - + /*****************************************************************/ void enkf_state_set_inactive(enkf_state_type * state); diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_types.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_types.h index 28e3000d8d..f361f5b308 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_types.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/enkf_types.h @@ -21,7 +21,7 @@ #ifdef __cplusplus extern "C" { #endif -#include + @@ -125,6 +125,13 @@ typedef enum {UNDEFINED = 0 , {.value = 6 , .name = "BOTH"} #define ENKF_STATE_ENUM_SIZE 4 + + + +typedef enum { REPORT_STEP_INCOMPATIBLE = 1, + LOAD_FAILURE = 2 } enkf_fw_load_result_enum; + + @@ -228,6 +235,15 @@ typedef enum { /*****************************************************************/ +/* Possible transitions: */ + typedef enum { + STATE_UNDEFINED = 1, + STATE_INITIALIZED = 2, + STATE_HAS_DATA = 4, + STATE_LOAD_FAILURE = 8, + STATE_PARENT_FAILURE = 16 + } realisation_state_enum; + typedef struct enkf_obs_struct enkf_obs_type; diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/meas_data.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/meas_data.h index 53f8f711cf..b46b66d96c 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/meas_data.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/meas_data.h @@ -27,10 +27,14 @@ extern "C" { #include #include +#include +#include typedef struct meas_data_struct meas_data_type; typedef struct meas_block_struct meas_block_type; + UTIL_IS_INSTANCE_HEADER( meas_data ); + void meas_block_iset( meas_block_type * meas_block , int iens , int iobs , double value); double meas_block_iget_ens_mean( const meas_block_type * meas_block , int iobs ); double meas_block_iget_ens_std( const meas_block_type * meas_block , int iobs); @@ -38,8 +42,8 @@ void meas_block_deactivate( meas_block_type * meas_block , int iob void meas_data_fprintf( const meas_data_type * matrix , FILE * stream); -void meas_data_reset(meas_data_type * ); -meas_data_type * meas_data_alloc( int ); + void meas_data_reset(meas_data_type * ); + meas_data_type * meas_data_alloc( const int_vector_type * ens_active_list ); void meas_data_free(meas_data_type * ); void meas_data_add(meas_data_type * , int , double ); matrix_type * meas_data_allocS(const meas_data_type * matrix , int active_size); @@ -56,7 +60,6 @@ void meas_block_calculate_ens_stats( meas_block_type * meas_block int meas_block_get_total_size( const meas_block_type * meas_block ); bool meas_block_iget_active( const meas_block_type * meas_block , int iobs); void meas_data_assign_vector(meas_data_type * target_matrix, const meas_data_type * src_matrix , int target_index , int src_index); -meas_data_type * meas_data_alloc_copy( const meas_data_type * src ); #ifdef __cplusplus } diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/model_config.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/model_config.h index 2f57e3fde6..6f0c673a95 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/model_config.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/model_config.h @@ -26,6 +26,7 @@ extern "C" { #include #include +#include #include @@ -55,6 +56,7 @@ extern "C" { const char * model_config_get_enspath( const model_config_type * model_config); const char * model_config_get_rftpath( const model_config_type * model_config); fs_driver_impl model_config_get_dbase_type(const model_config_type * model_config ); + const ecl_sum_type * model_config_get_refcase( const model_config_type * model_config ); void model_config_init_internalization( model_config_type * ); void model_config_set_internalize_state( model_config_type * , int ); void model_config_set_load_state( model_config_type * , int ); @@ -82,8 +84,11 @@ extern "C" { history_source_type model_config_get_history_source( const model_config_type * model_config ); void model_config_set_refcase( model_config_type * model_config , const ecl_sum_type * refcase ); void model_config_fprintf_config( const model_config_type * model_config , int ens_size ,FILE * stream ); - model_config_type * model_config_alloc_empty(); + model_config_type * model_config_alloc(); bool model_config_select_history( model_config_type * model_config , history_source_type source_type, const sched_file_type * sched_file , const ecl_sum_type * refcase); + void model_config_set_runpath(model_config_type * model_config , const char * fmt); + + UTIL_IS_INSTANCE_HEADER( model_config); #ifdef __cplusplus } diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/obs_vector.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/obs_vector.h index fc381374e0..4f1aefbfd2 100644 --- a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/obs_vector.h +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/obs_vector.h @@ -63,7 +63,7 @@ extern "C" { int obs_vector_get_num_active(const obs_vector_type * ); bool obs_vector_iget_active(const obs_vector_type * , int ); void obs_vector_iget_observations(const obs_vector_type * , int , obs_data_type * , const active_list_type * active_list); - void obs_vector_measure(const obs_vector_type * , enkf_fs_type * fs, state_enum state , int report_step , const enkf_state_type * , meas_data_type * , const active_list_type * active_list); + void obs_vector_measure(const obs_vector_type * , enkf_fs_type * fs, state_enum state , int report_step , int active_iens_index , const enkf_state_type * , meas_data_type * , const active_list_type * active_list); const char * obs_vector_get_state_kw(const obs_vector_type * ); obs_impl_type obs_vector_get_impl_type(const obs_vector_type * ); int obs_vector_get_active_report_step(const obs_vector_type * ); diff --git a/ThirdParty/Ert/devel/libenkf/include/ert/enkf/state_map.h b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/state_map.h new file mode 100644 index 0000000000..ef6288b787 --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/include/ert/enkf/state_map.h @@ -0,0 +1,56 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + The file 'state_map.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ + +#ifndef __STATE_MAP_H__ +#define __STATE_MAP_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include + + typedef struct state_map_struct state_map_type; + + + state_map_type * state_map_alloc( ); + state_map_type * state_map_fread_alloc( const char * filename ); + state_map_type * state_map_alloc_copy( state_map_type * map ); + void state_map_free( state_map_type * map ); + int state_map_get_size( state_map_type * map); + realisation_state_enum state_map_iget( state_map_type * map , int index); + void state_map_update_undefined( state_map_type * map , int index , realisation_state_enum new_state); + void state_map_iset( state_map_type * map ,int index , realisation_state_enum state); + bool state_map_equal( state_map_type * map1 , state_map_type * map2); + void state_map_fwrite( state_map_type * map , const char * filename); + void state_map_fread( state_map_type * map , const char * filename); + void state_map_select_matching( state_map_type * map , bool_vector_type * select_target , int select_mask); + void state_map_deselect_matching( state_map_type * map , bool_vector_type * select_target , int select_mask); + void state_map_set_from_inverted_mask(state_map_type * map, const bool_vector_type *mask , realisation_state_enum state); + void state_map_set_from_mask(state_map_type * map, const bool_vector_type *mask , realisation_state_enum state); + int state_map_count_matching( state_map_type * state_map , int mask); + + UTIL_IS_INSTANCE_HEADER( state_map ); + + +#ifdef __cplusplus +} +#endif +#endif diff --git a/ThirdParty/Ert/devel/libenkf/src/CMakeLists.txt b/ThirdParty/Ert/devel/libenkf/src/CMakeLists.txt index ba08fa8437..dd72020b27 100644 --- a/ThirdParty/Ert/devel/libenkf/src/CMakeLists.txt +++ b/ThirdParty/Ert/devel/libenkf/src/CMakeLists.txt @@ -1,6 +1,6 @@ -set( source_files ert_report.c time_map.c rng_config.c trans_func.c enkf_types.c enkf_obs.c obs_data.c block_obs.c enkf_config_node.c field_config.c field.c ecl_static_kw.c enkf_state.c enkf_util.c enkf_node.c gen_kw_config.c gen_kw.c enkf_fs.c fs_driver.c meas_data.c summary_obs.c summary.c summary_config.c gen_data_config.c gen_data.c gen_common.c gen_obs.c enkf_sched.c enkf_serialize.c ecl_config.c enkf_defaults.c ensemble_config.c model_config.c site_config.c active_list.c obs_vector.c field_trans.c plain_driver.c local_ministep.c local_updatestep.c container_config.c container.c local_context.c local_config.c analysis_config.c misfit_ensemble.c misfit_member.c misfit_ts.c data_ranking.c misfit_ranking.c ranking_table.c fs_types.c block_fs_driver.c plot_config.c ert_template.c member_config.c enkf_analysis.c enkf_main.c local_dataset.c local_obsset.c surface.c surface_config.c enkf_plot_data.c enkf_plot_member.c qc_module.c ert_report_list.c enkf_plot_arg.c runpath_list.c ert_workflow_list.c analysis_iter_config.c enkf_main_jobs.c ecl_refcase_list.c) +set( source_files ert_report.c time_map.c rng_config.c trans_func.c enkf_types.c enkf_obs.c obs_data.c block_obs.c enkf_config_node.c field_config.c field.c ecl_static_kw.c enkf_state.c enkf_util.c enkf_node.c gen_kw_config.c gen_kw.c enkf_fs.c fs_driver.c meas_data.c summary_obs.c summary.c summary_config.c gen_data_config.c gen_data.c gen_common.c gen_obs.c enkf_sched.c enkf_serialize.c ecl_config.c enkf_defaults.c ensemble_config.c model_config.c site_config.c active_list.c obs_vector.c field_trans.c plain_driver.c local_ministep.c local_updatestep.c container_config.c container.c local_context.c local_config.c analysis_config.c misfit_ensemble.c misfit_member.c misfit_ts.c data_ranking.c misfit_ranking.c ranking_table.c fs_types.c block_fs_driver.c plot_config.c ert_template.c member_config.c enkf_analysis.c enkf_main.c local_dataset.c local_obsset.c surface.c surface_config.c enkf_plot_data.c enkf_plot_member.c qc_module.c ert_report_list.c enkf_plot_arg.c runpath_list.c ert_workflow_list.c analysis_iter_config.c enkf_main_jobs.c ecl_refcase_list.c cases_config.c state_map.c) -set( header_files ert_report.h time_map.h rng_config.h enkf_analysis.h enkf_fs_type.h trans_func.h enkf_obs.h obs_data.h enkf_config_node.h block_obs.h field_config.h field.h enkf_macros.h ecl_static_kw.h enkf_state.h enkf_util.h enkf_main.h enkf_node.h enkf_fs.h gen_kw_config.h gen_kw.h enkf_types.h fs_driver.h meas_data.h summary_obs.h summary_config.h summary_config.h gen_data_config.h gen_data.h gen_common.h gen_obs.h enkf_sched.h fs_types.h enkf_serialize.h plain_driver.h ecl_config.h ensemble_config.h model_config.h site_config.h active_list.h obs_vector.h field_trans.h plain_driver.h local_ministep.h container.h local_updatestep.h local_config.h analysis_config.h misfit_ensemble.h misfit_ensemble_typedef.h misfit_ts.h misfit_member.h data_ranking.h ranking_table.h ranking_common.h misfit_ranking.h block_fs_driver.h field_common.h gen_kw_common.h gen_data_common.h plot_config.h ert_template.h member_config.h enkf_defaults.h container_config.h local_dataset.h local_obsset.h surface.h surface_config.h local_context.h enkf_plot_data.h enkf_plot_member.h qc_module.h ert_report_list.h enkf_plot_arg.h runpath_list.h ert_workflow_list.h analysis_iter_config.h ecl_refcase_list.h) +set( header_files ert_report.h time_map.h rng_config.h enkf_analysis.h enkf_fs_type.h trans_func.h enkf_obs.h obs_data.h enkf_config_node.h block_obs.h field_config.h field.h enkf_macros.h ecl_static_kw.h enkf_state.h enkf_util.h enkf_main.h enkf_node.h enkf_fs.h gen_kw_config.h gen_kw.h enkf_types.h fs_driver.h meas_data.h summary_obs.h summary_config.h summary_config.h gen_data_config.h gen_data.h gen_common.h gen_obs.h enkf_sched.h fs_types.h enkf_serialize.h plain_driver.h ecl_config.h ensemble_config.h model_config.h site_config.h active_list.h obs_vector.h field_trans.h plain_driver.h local_ministep.h container.h local_updatestep.h local_config.h analysis_config.h misfit_ensemble.h misfit_ensemble_typedef.h misfit_ts.h misfit_member.h data_ranking.h ranking_table.h ranking_common.h misfit_ranking.h block_fs_driver.h field_common.h gen_kw_common.h gen_data_common.h plot_config.h ert_template.h member_config.h enkf_defaults.h container_config.h local_dataset.h local_obsset.h surface.h surface_config.h local_context.h enkf_plot_data.h enkf_plot_member.h qc_module.h ert_report_list.h enkf_plot_arg.h runpath_list.h ert_workflow_list.h analysis_iter_config.h ecl_refcase_list.h cases_config.h state_map.h) add_library( enkf ${LIBRARY_TYPE} ${source_files} ) set_target_properties( enkf PROPERTIES VERSION 1.0 SOVERSION 1.0 ) diff --git a/ThirdParty/Ert/devel/libenkf/src/analysis_config.c b/ThirdParty/Ert/devel/libenkf/src/analysis_config.c index 3e5fef6893..3c0d4fdc70 100644 --- a/ThirdParty/Ert/devel/libenkf/src/analysis_config.c +++ b/ThirdParty/Ert/devel/libenkf/src/analysis_config.c @@ -24,6 +24,7 @@ #include #include #include +#include #include @@ -36,7 +37,10 @@ #include +#define ANALYSIS_CONFIG_TYPE_ID 64431306 + struct analysis_config_struct { + UTIL_TYPE_ID_DECLARATION; hash_type * analysis_modules; analysis_module_type * analysis_module; char * log_path; /* Points to directory with update logs. */ @@ -54,12 +58,13 @@ struct analysis_config_struct { bool single_node_update; /* When creating the default ALL_ACTIVE local configuration. */ rng_type * rng; analysis_iter_config_type * iter_config; + int min_realisations; }; - +UTIL_IS_INSTANCE_FUNCTION( analysis_config , ANALYSIS_CONFIG_TYPE_ID ) /*****************************************************************/ /* @@ -116,7 +121,29 @@ ANALYSIS_SELECT ModuleName /*****************************************************************/ +bool analysis_config_have_enough_realisations( const analysis_config_type * config , int realisations) { + if (config->min_realisations > 0) { + /* A value > 0 has been set in the config; compare with this value. */ + if (realisations >= config->min_realisations) + return true; + else + return false; + } else { + /* No value has been set in the config; just compare the input with zero. */ + if (realisations > 0) + return true; + else + return false; + } +} +void analysis_config_set_min_realisations( analysis_config_type * config , int min_realisations) { + config->min_realisations = min_realisations; +} + +int analysis_config_get_min_realisations( const analysis_config_type * config ) { + return config->min_realisations; +} void analysis_config_set_alpha( analysis_config_type * config , double alpha) { config->overlap_alpha = alpha; @@ -371,6 +398,9 @@ void analysis_config_init( analysis_config_type * analysis , const config_type * if (config_item_set( config , RERUN_START_KEY )) analysis_config_set_rerun_start( analysis , config_get_value_as_int( config , RERUN_START_KEY )); + + if (config_item_set( config , MIN_REALIZATIONS_KEY )) + analysis_config_set_min_realisations( analysis , config_get_value_as_int( config , MIN_REALIZATIONS_KEY )); /* Loading external modules */ { @@ -458,8 +488,9 @@ void analysis_config_free(analysis_config_type * config) { -analysis_config_type * analysis_config_alloc_default( rng_type * rng ) { +analysis_config_type * analysis_config_alloc( rng_type * rng ) { analysis_config_type * config = util_malloc( sizeof * config ); + UTIL_TYPE_ID_INIT( config , ANALYSIS_CONFIG_TYPE_ID ); config->log_path = NULL; config->PC_filename = NULL; @@ -477,6 +508,7 @@ analysis_config_type * analysis_config_alloc_default( rng_type * rng ) { analysis_config_set_store_PC( config , DEFAULT_STORE_PC ); analysis_config_set_PC_filename( config , DEFAULT_PC_FILENAME ); analysis_config_set_PC_path( config , DEFAULT_PC_PATH ); + analysis_config_set_min_realisations( config , DEFAULT_ANALYSIS_MIN_REALISATIONS ); config->analysis_module = NULL; config->analysis_modules = hash_alloc(); @@ -514,6 +546,7 @@ void analysis_config_add_config_items( config_type * config ) { config_add_key_value( config , ENKF_RERUN_KEY , false , CONFIG_BOOL); config_add_key_value( config , RERUN_START_KEY , false , CONFIG_INT); config_add_key_value( config , UPDATE_LOG_PATH_KEY , false , CONFIG_STRING); + config_add_key_value( config , MIN_REALIZATIONS_KEY , false , CONFIG_INT ); config_add_key_value( config , ANALYSIS_SELECT_KEY , false , CONFIG_STRING); @@ -553,7 +586,7 @@ void analysis_config_fprintf_config( analysis_config_type * config , FILE * stre } if (config->overlap_alpha != DEFAULT_ENKF_ALPHA ) { - fprintf( stream , CONFIG_KEY_FORMAT , ENKF_TRUNCATION_KEY ); + fprintf( stream , CONFIG_KEY_FORMAT , ENKF_ALPHA_KEY ); fprintf( stream , CONFIG_FLOAT_FORMAT , config->overlap_alpha ); fprintf( stream , "\n"); } diff --git a/ThirdParty/Ert/devel/libenkf/src/analysis_iter_config.c b/ThirdParty/Ert/devel/libenkf/src/analysis_iter_config.c index c0bd8debe7..04847a9ae3 100644 --- a/ThirdParty/Ert/devel/libenkf/src/analysis_iter_config.c +++ b/ThirdParty/Ert/devel/libenkf/src/analysis_iter_config.c @@ -47,24 +47,6 @@ int analysis_iter_config_get_num_iterations( const analysis_iter_config_type * c return config->num_iterations; } - - -analysis_iter_config_type * analysis_iter_config_alloc() { - analysis_iter_config_type * config = util_malloc( sizeof * config ); - config->runpath_fmt = NULL; - config->case_fmt = NULL; - config->storage = stringlist_alloc_new(); - analysis_iter_config_set_num_iterations( config , DEFAULT_ANALYSIS_NUM_ITERATIONS ); - return config; -} - -void analysis_iter_config_free( analysis_iter_config_type * config ) { - util_safe_free( config->runpath_fmt ); - util_safe_free( config->case_fmt ); - stringlist_free( config->storage ); -} - - /** This should contain a format string with two %d modifiers, the first will be replaced with the iteration number, and the second @@ -86,10 +68,36 @@ static void analysis_iter_config_set_runpath_fmt( analysis_iter_config_type * co } } -static void analysis_iter_config_set_case_fmt( analysis_iter_config_type * config , const char * case_fmt) { +void analysis_iter_config_set_case_fmt( analysis_iter_config_type * config , const char * case_fmt) { config->case_fmt = util_realloc_string_copy( config->case_fmt , case_fmt ); } +char * analysis_iter_config_get_case_fmt( analysis_iter_config_type * config) { + return config->case_fmt; +} + + +analysis_iter_config_type * analysis_iter_config_alloc() { + analysis_iter_config_type * config = util_malloc( sizeof * config ); + config->runpath_fmt = NULL; + analysis_iter_config_set_runpath_fmt( config, DEFAULT_ANALYSIS_ITER_RUNPATH); + config->case_fmt = NULL; + analysis_iter_config_set_case_fmt( config, DEFAULT_ANALYSIS_ITER_CASE); + config->storage = stringlist_alloc_new(); + analysis_iter_config_set_num_iterations( config , DEFAULT_ANALYSIS_NUM_ITERATIONS ); + return config; +} + +void analysis_iter_config_free( analysis_iter_config_type * config ) { + util_safe_free( config->runpath_fmt ); + util_safe_free( config->case_fmt ); + stringlist_free( config->storage ); +} + + + + + const char * analysis_iter_config_iget_runpath_fmt( analysis_iter_config_type * config , int iter) { if (config->runpath_fmt != NULL) { char * runpath_fmt = util_alloc_sprintf( config->runpath_fmt , iter ); diff --git a/ThirdParty/Ert/devel/libenkf/src/cases_config.c b/ThirdParty/Ert/devel/libenkf/src/cases_config.c new file mode 100644 index 0000000000..bfe7537ba3 --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/src/cases_config.c @@ -0,0 +1,86 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'cases_config.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ + + +#include +#include +#include + +#include +#include + +#include + +#include +#include +#include + + +struct cases_config_struct { + int iteration_number; +}; + + +cases_config_type * cases_config_alloc( ) { + cases_config_type * config = util_malloc( sizeof * config ); + config->iteration_number = 0; + return config; +} + + +static void cases_config_set_iteration_number( cases_config_type * config , int num_iterations) { + config->iteration_number = num_iterations; +} + +int cases_config_get_iteration_number( const cases_config_type * config ) { + return config->iteration_number; +} + +bool cases_config_set_int( cases_config_type * cases_config , const char * var_name , int value) { + bool name_recognized = true; + if (strcmp( var_name , "iteration_number") == 0) + cases_config_set_iteration_number(cases_config, value); + else + name_recognized = false; + + return name_recognized; +} + + + +void cases_config_fwrite( cases_config_type * config , const char * filename ) { + FILE * stream = util_mkdir_fopen(filename , "w"); + int iteration_no = cases_config_get_iteration_number(config); + util_fwrite_int( iteration_no , stream ); + fclose( stream ); +} + +void cases_config_fread( cases_config_type * config , const char * filename) { + if (util_file_exists( filename )) { + FILE * stream = util_fopen( filename , "r"); + int iteration_number = util_fread_int( stream ); + cases_config_set_iteration_number(config,iteration_number); + fclose( stream ); + } +} + + +void cases_config_free( cases_config_type * config ) { + free( config ); +} + diff --git a/ThirdParty/Ert/devel/libenkf/src/ecl_config.c b/ThirdParty/Ert/devel/libenkf/src/ecl_config.c index d9b6624dd7..8931f6ceae 100644 --- a/ThirdParty/Ert/devel/libenkf/src/ecl_config.c +++ b/ThirdParty/Ert/devel/libenkf/src/ecl_config.c @@ -193,6 +193,13 @@ bool ecl_config_has_schedule( const ecl_config_type * ecl_config ) { return true; } +bool ecl_config_has_init_section( const ecl_config_type * ecl_config ) { + if (ecl_config->init_section == NULL) + return false; + else + return true; +} + /** Observe: This function makes a hard assumption that the @@ -311,7 +318,10 @@ void ecl_config_set_init_section( ecl_config_type * ecl_config , const char * in 2. If the INIT_SECTION points to a not existing file: a. We assert that INIT_SECTION points to a pure filename, - i.e. /some/path/which/does/not/exist is NOT accepted. + i.e. /some/path/which/does/not/exist is NOT accepted. In + the case the input argument contain a path a error message + will be printed on stderr and the ->init_section will not + be set. b. The ecl_config->input_init_section is set to point to this file. c. WE TRUST THE USER TO SUPPLY CONTENT (THROUGH SOME FUNKY @@ -351,7 +361,7 @@ void ecl_config_set_init_section( ecl_config_type * ecl_config , const char * in */ if (ecl_config->can_restart) { /* The tag is set. */ - ecl_config->input_init_section = util_realloc_string_copy( ecl_config->input_init_section , input_init_section ); /* input_init_section = path/to/init_section */ + ecl_config->input_init_section = util_realloc_string_copy( ecl_config->input_init_section , input_init_section ); /* input_init_section = path/to/init_section */ if (util_file_exists( ecl_config->input_init_section )) { /* init_section = $CWD/path/to/init_section */ util_safe_free( ecl_config->init_section ); ecl_config->init_section = util_alloc_realpath(input_init_section); @@ -360,10 +370,11 @@ void ecl_config_set_init_section( ecl_config_type * ecl_config , const char * in util_alloc_file_components( ecl_config->input_init_section , &path , NULL , NULL ); if (path != NULL) - util_abort("%s: When INIT_SECTION:%s is set to a non-existing file - you can not have any path components.\n",__func__ , input_init_section); + fprintf(stderr,"** Warning: %s: When INIT_SECTION:%s points to a non-existing file - you can not have any path components.\n",__func__ , input_init_section); + else + ecl_config->init_section = util_alloc_string_copy(input_init_section); util_safe_free( path ); - ecl_config->init_section = util_alloc_string_copy(input_init_section); } } else /* diff --git a/ThirdParty/Ert/devel/libenkf/src/enkf_fs.c b/ThirdParty/Ert/devel/libenkf/src/enkf_fs.c index 1222c2e9bf..09f63f9ef2 100644 --- a/ThirdParty/Ert/devel/libenkf/src/enkf_fs.c +++ b/ThirdParty/Ert/devel/libenkf/src/enkf_fs.c @@ -42,8 +42,9 @@ #include #include #include +#include #include - +#include /** @@ -204,7 +205,9 @@ #define ENKF_FS_TYPE_ID 1089763 #define ENKF_MOUNT_MAP "enkf_mount_info" #define TIME_MAP_FILE "time-map" +#define STATE_MAP_FILE "state-map" #define MISFIT_ENSEMBLE_FILE "misfit-ensemble" +#define CASE_CONFIG_FILE "case_config" struct enkf_fs_struct { UTIL_TYPE_ID_DECLARATION; @@ -221,6 +224,8 @@ struct enkf_fs_struct { bool read_only; /* Whether this filesystem has been mounted read-only. */ time_map_type * time_map; + cases_config_type * cases_config; + state_map_type * state_map; misfit_ensemble_type * misfit_ensemble; /* The variables below here are for storing arbitrary files within @@ -242,6 +247,8 @@ static enkf_fs_type * enkf_fs_alloc_empty( const char * mount_point , bool read_ enkf_fs_type * fs = util_malloc(sizeof * fs ); UTIL_TYPE_ID_INIT( fs , ENKF_FS_TYPE_ID ); fs->time_map = time_map_alloc(); + fs->cases_config = cases_config_alloc(); + fs->state_map = state_map_alloc(); fs->misfit_ensemble = misfit_ensemble_alloc(); fs->index = NULL; fs->eclipse_static = NULL; @@ -438,6 +445,35 @@ static void enkf_fs_fread_time_map( enkf_fs_type * fs ) { } +static void enkf_fs_fsync_cases_config( enkf_fs_type * fs ) { + char * filename = enkf_fs_alloc_case_filename( fs , CASE_CONFIG_FILE ); + cases_config_fwrite( fs->cases_config , filename ); + free( filename ); +} + +static void enkf_fs_fsync_state_map( enkf_fs_type * fs ) { + char * filename = enkf_fs_alloc_case_filename( fs , STATE_MAP_FILE ); + state_map_fwrite( fs->state_map , filename ); + free( filename ); +} + + + +static void enkf_fs_fread_cases_config( enkf_fs_type * fs ) { + char * filename = enkf_fs_alloc_case_filename( fs , CASE_CONFIG_FILE ); + cases_config_fread( fs->cases_config , filename ); + free( filename ); +} + + +static void enkf_fs_fread_state_map( enkf_fs_type * fs ) { + char * filename = enkf_fs_alloc_case_filename( fs , STATE_MAP_FILE ); + state_map_fread( fs->state_map , filename ); + free( filename ); +} + + + static void enkf_fs_fread_misfit( enkf_fs_type * fs ) { FILE * stream = enkf_fs_open_excase_file( fs , MISFIT_ENSEMBLE_FILE ); if (stream != NULL) { @@ -480,6 +516,8 @@ enkf_fs_type * enkf_fs_open( const char * mount_point , bool read_only) { fclose( stream ); enkf_fs_init_path_fmt( fs ); enkf_fs_fread_time_map( fs ); + enkf_fs_fread_cases_config( fs ); + enkf_fs_fread_state_map( fs ); enkf_fs_fread_misfit( fs ); } return fs; @@ -528,7 +566,9 @@ void enkf_fs_close( enkf_fs_type * fs ) { path_fmt_free( fs->case_tstep_fmt ); path_fmt_free( fs->case_tstep_member_fmt ); + state_map_free( fs->state_map ); time_map_free( fs->time_map ); + cases_config_free( fs->cases_config ); free( fs ); } @@ -590,6 +630,8 @@ void enkf_fs_fsync( enkf_fs_type * fs ) { enkf_fs_fsync_driver( fs->index ); enkf_fs_fsync_time_map( fs ); + enkf_fs_fsync_cases_config( fs) ; + enkf_fs_fsync_state_map( fs ); } @@ -869,6 +911,14 @@ time_map_type * enkf_fs_get_time_map( const enkf_fs_type * fs ) { return fs->time_map; } +cases_config_type * enkf_fs_get_cases_config( const enkf_fs_type * fs) { + return fs->cases_config; +} + +state_map_type * enkf_fs_get_state_map( const enkf_fs_type * fs ) { + return fs->state_map; +} + misfit_ensemble_type * enkf_fs_get_misfit_ensemble( const enkf_fs_type * fs ) { return fs->misfit_ensemble; diff --git a/ThirdParty/Ert/devel/libenkf/src/enkf_main.c b/ThirdParty/Ert/devel/libenkf/src/enkf_main.c index 8ddebb290a..b92fcfa4ec 100644 --- a/ThirdParty/Ert/devel/libenkf/src/enkf_main.c +++ b/ThirdParty/Ert/devel/libenkf/src/enkf_main.c @@ -47,8 +47,10 @@ #include #include #include +#include #include +#include #include #include @@ -67,6 +69,7 @@ #include #include + #include #include #include @@ -98,6 +101,8 @@ #include #include #include +#include +#include /**/ @@ -735,6 +740,7 @@ typedef struct { int row_offset; const active_list_type * active_list; matrix_type * A; + const int_vector_type * iens_active_index; } serialize_info_type; @@ -746,21 +752,33 @@ static void serialize_node( enkf_fs_type * fs , int report_step , state_enum load_state , int row_offset , + int column, const active_list_type * active_list, matrix_type * A) { enkf_node_type * node = enkf_state_get_node( ensemble[iens] , key); node_id_type node_id = {.report_step = report_step, .iens = iens , .state = load_state }; - enkf_node_serialize( node , fs , node_id , active_list , A , row_offset , iens); + enkf_node_serialize( node , fs , node_id , active_list , A , row_offset , column); } static void * serialize_nodes_mt( void * arg ) { serialize_info_type * info = (serialize_info_type *) arg; int iens; - for (iens = info->iens1; iens < info->iens2; iens++) - serialize_node( info->src_fs , info->ensemble , info->key , iens , info->report_step , info->load_state , info->row_offset , info->active_list , info->A ); - + for (iens = info->iens1; iens < info->iens2; iens++) { + int column = int_vector_iget( info->iens_active_index , iens); + if (column >= 0) + serialize_node( info->src_fs , + info->ensemble , + info->key , + iens , + info->report_step , + info->load_state , + info->row_offset , + column, + info->active_list , + info->A ); + } return NULL; } @@ -782,7 +800,7 @@ static void enkf_main_serialize_node( const char * node_key , serialize_info[icpu].active_list = active_list; serialize_info[icpu].load_state = load_state; serialize_info[icpu].row_offset = row_offset; - + thread_pool_add_job( work_pool , serialize_nodes_mt , &serialize_info[icpu]); } thread_pool_join( work_pool ); @@ -857,12 +875,14 @@ static void deserialize_node( enkf_fs_type * fs, int iens, int target_step , int row_offset , + int column, const active_list_type * active_list, matrix_type * A) { enkf_node_type * node = enkf_state_get_node( ensemble[iens] , key); node_id_type node_id = { .report_step = target_step , .iens = iens , .state = ANALYZED }; - enkf_node_deserialize(node , fs , node_id , active_list , A , row_offset , iens); + enkf_node_deserialize(node , fs , node_id , active_list , A , row_offset , column); + state_map_update_undefined(enkf_fs_get_state_map(fs) , iens , STATE_INITIALIZED); } @@ -870,9 +890,11 @@ static void deserialize_node( enkf_fs_type * fs, static void * deserialize_nodes_mt( void * arg ) { serialize_info_type * info = (serialize_info_type *) arg; int iens; - for (iens = info->iens1; iens < info->iens2; iens++) - deserialize_node( info->target_fs , info->ensemble , info->key , iens , info->target_step , info->row_offset , info->active_list , info->A ); - + for (iens = info->iens1; iens < info->iens2; iens++) { + int column = int_vector_iget( info->iens_active_index , iens ); + if (column >= 0) + deserialize_node( info->target_fs , info->ensemble , info->key , iens , info->target_step , info->row_offset , column, info->active_list , info->A ); + } return NULL; } @@ -924,12 +946,22 @@ static void serialize_info_free( serialize_info_type * serialize_info ) { free( serialize_info ); } -static serialize_info_type * serialize_info_alloc( enkf_fs_type * src_fs, enkf_fs_type * target_fs , int target_step , enkf_state_type ** ensemble , run_mode_type run_mode , int report_step , matrix_type * A , int num_cpu_threads ) { +static serialize_info_type * serialize_info_alloc( enkf_fs_type * src_fs, + enkf_fs_type * target_fs , + const int_vector_type * iens_active_index , + int target_step , + enkf_state_type ** ensemble , + run_mode_type run_mode , + int report_step , + matrix_type * A , + int num_cpu_threads ) { + serialize_info_type * serialize_info = util_calloc( num_cpu_threads , sizeof * serialize_info ); - int ens_size = matrix_get_columns( A ); + int ens_size = int_vector_size(iens_active_index); int icpu; int iens_offset = 0; for (icpu = 0; icpu < num_cpu_threads; icpu++) { + serialize_info[icpu].iens_active_index = iens_active_index; serialize_info[icpu].run_mode = run_mode; serialize_info[icpu].src_fs = src_fs; serialize_info[icpu].target_fs = target_fs; @@ -988,6 +1020,7 @@ void enkf_main_get_PC( const enkf_main_type * enkf_main , static void enkf_main_analysis_update( enkf_main_type * enkf_main , enkf_fs_type * target_fs , + const bool_vector_type * ens_mask , int target_step , hash_type * use_count, run_mode_type run_mode , @@ -1011,20 +1044,20 @@ static void enkf_main_analysis_update( enkf_main_type * enkf_main , matrix_type * E = NULL; matrix_type * D = NULL; matrix_type * localA = NULL; - - - + int_vector_type * iens_active_index = bool_vector_alloc_active_index_list(ens_mask , -1); if (analysis_module_get_option( module , ANALYSIS_NEED_ED)) { E = obs_data_allocE( obs_data , enkf_main->rng , ens_size , active_size ); D = obs_data_allocD( obs_data , E , S ); } - if (analysis_module_get_option( module , ANALYSIS_SCALE_DATA)) + if (analysis_module_get_option( module , ANALYSIS_SCALE_DATA)){ obs_data_scale( obs_data , S , E , D , R , dObs ); + } - if (analysis_module_get_option( module , ANALYSIS_USE_A | ANALYSIS_UPDATE_A)) + if (analysis_module_get_option( module , ANALYSIS_USE_A | ANALYSIS_UPDATE_A)){ localA = A; + } /*****************************************************************/ @@ -1032,7 +1065,15 @@ static void enkf_main_analysis_update( enkf_main_type * enkf_main , { hash_iter_type * dataset_iter = local_ministep_alloc_dataset_iter( ministep ); enkf_fs_type * src_fs = enkf_main_get_fs( enkf_main ); - serialize_info_type * serialize_info = serialize_info_alloc( src_fs , target_fs , target_step , enkf_main_get_ensemble( enkf_main ) , run_mode , step2 , A , cpu_threads); + serialize_info_type * serialize_info = serialize_info_alloc( src_fs , + target_fs , + iens_active_index, + target_step , + enkf_main_get_ensemble( enkf_main ) , + run_mode , + step2 , + A , + cpu_threads); // Store PC: if (analysis_config_get_store_PC( enkf_main->analysis_config )) { @@ -1047,8 +1088,10 @@ static void enkf_main_analysis_update( enkf_main_type * enkf_main , matrix_free( PC_obs ); } - if (localA == NULL) + if (localA == NULL){ analysis_module_initX( module , X , NULL , S , R , dObs , E , D ); + } + while (!hash_iter_is_complete( dataset_iter )) { const char * dataset_name = hash_iter_get_next_key( dataset_iter ); @@ -1059,11 +1102,21 @@ static void enkf_main_analysis_update( enkf_main_type * enkf_main , enkf_main_serialize_dataset( enkf_main , dataset , step2 , use_count , active_size , row_offset , tp , serialize_info); - if (analysis_module_get_option( module , ANALYSIS_UPDATE_A)) - analysis_module_updateA( module , localA , S , R , dObs , E , D ); + if (analysis_module_get_option( module , ANALYSIS_UPDATE_A)){ + if (analysis_module_get_option( module , ANALYSIS_ITERABLE)){ + int iteration = cases_config_get_iteration_number(enkf_fs_get_cases_config(src_fs)); + char iteration_str[15]; + sprintf(iteration_str,"%d",iteration); + analysis_module_set_var( module , "NUM_ITER", iteration_str); + analysis_module_updateA( module , localA , S , R , dObs , E , D ); + } + else + analysis_module_updateA( module , localA , S , R , dObs , E , D ); + } else { - if (analysis_module_get_option( module , ANALYSIS_USE_A)) + if (analysis_module_get_option( module , ANALYSIS_USE_A)){ analysis_module_initX( module , X , localA , S , R , dObs , E , D ); + } matrix_inplace_matmul_mt2( A , X , tp ); } @@ -1084,6 +1137,7 @@ static void enkf_main_analysis_update( enkf_main_type * enkf_main , /*****************************************************************/ + int_vector_free(iens_active_index); matrix_safe_free( E ); matrix_safe_free( D ); matrix_free( S ); @@ -1100,101 +1154,131 @@ static void enkf_main_analysis_update( enkf_main_type * enkf_main , **/ -static void enkf_main_UPDATE(enkf_main_type * enkf_main , const int_vector_type * step_list, enkf_fs_type * target_fs , int target_step , run_mode_type run_mode) { +static bool enkf_main_UPDATE(enkf_main_type * enkf_main , const int_vector_type * step_list, enkf_fs_type * target_fs , int target_step , run_mode_type run_mode) { /* If merge_observations is true all observations in the time interval [step1+1,step2] will be used, otherwise only the last observation at step2 will be used. */ - const int ens_size = enkf_main_get_ensemble_size(enkf_main); - double alpha = analysis_config_get_alpha( enkf_main->analysis_config ); - double std_cutoff = analysis_config_get_std_cutoff( enkf_main->analysis_config ); - int current_step = int_vector_get_last( step_list ); - { - /* - Observations and measurements are collected in these temporary - structures. obs_data is a precursor for the 'd' vector, and - meas_forecast is a precursor for the 'S' matrix'. + enkf_fs_type * source_fs = enkf_main_get_fs(enkf_main); + state_map_type * source_state_map = enkf_fs_get_state_map( source_fs ); + const analysis_config_type * analysis_config = enkf_main_get_analysis_config( enkf_main ); + const int active_ens_size = state_map_count_matching( source_state_map , STATE_HAS_DATA ); - The reason for going via these temporary structures is to support - deactivating observations which should not be used in the update - process. - */ - obs_data_type * obs_data = obs_data_alloc(); - meas_data_type * meas_forecast = meas_data_alloc( ens_size ); - meas_data_type * meas_analyzed = meas_data_alloc( ens_size ); - local_config_type * local_config = enkf_main->local_config; - const local_updatestep_type * updatestep = local_config_iget_updatestep( local_config , current_step ); /* Only last step considered when forming local update */ - hash_type * use_count = hash_alloc(); - const char * log_path = analysis_config_get_log_path( enkf_main->analysis_config ); - FILE * log_stream; + if (analysis_config_have_enough_realisations(analysis_config , active_ens_size)) { + double alpha = analysis_config_get_alpha( enkf_main->analysis_config ); + double std_cutoff = analysis_config_get_std_cutoff( enkf_main->analysis_config ); + int current_step = int_vector_get_last( step_list ); + const int total_ens_size = enkf_main_get_ensemble_size(enkf_main); + state_map_type * target_state_map = enkf_fs_get_state_map( target_fs ); + bool_vector_type * ens_mask = bool_vector_alloc(total_ens_size , false); + int_vector_type * ens_active_list = int_vector_alloc(0,0); - + + state_map_select_matching( source_state_map , ens_mask , STATE_HAS_DATA ); + ens_active_list = bool_vector_alloc_active_list( ens_mask ); { - char * log_file; - if (int_vector_size( step_list ) == 1) - log_file = util_alloc_sprintf("%s%c%04d" , log_path , UTIL_PATH_SEP_CHAR , int_vector_iget( step_list , 0)); - else - log_file = util_alloc_sprintf("%s%c%04d-%04d" , log_path , UTIL_PATH_SEP_CHAR , int_vector_iget( step_list , 0) , int_vector_get_last( step_list )); - log_stream = util_fopen( log_file , "w" ); - - free( log_file ); - } + /* + Observations and measurements are collected in these temporary + structures. obs_data is a precursor for the 'd' vector, and + meas_forecast is a precursor for the 'S' matrix'. + + The reason for going via these temporary structures is to support + deactivating observations which should not be used in the update + process. + */ + obs_data_type * obs_data = obs_data_alloc(); + meas_data_type * meas_forecast = meas_data_alloc( ens_active_list ); + meas_data_type * meas_analyzed = meas_data_alloc( ens_active_list ); + local_config_type * local_config = enkf_main->local_config; + const local_updatestep_type * updatestep = local_config_iget_updatestep( local_config , current_step ); /* Only last step considered when forming local update */ + hash_type * use_count = hash_alloc(); + const char * log_path = analysis_config_get_log_path( enkf_main->analysis_config ); + FILE * log_stream; + - for (int ministep_nr = 0; ministep_nr < local_updatestep_get_num_ministep( updatestep ); ministep_nr++) { /* Looping over local analysis ministep */ - local_ministep_type * ministep = local_updatestep_iget_ministep( updatestep , ministep_nr ); - local_obsset_type * obsset = local_ministep_get_obsset( ministep ); - - obs_data_reset( obs_data ); - meas_data_reset( meas_forecast ); + { + char * log_file; + if (int_vector_size( step_list ) == 1) + log_file = util_alloc_sprintf("%s%c%04d" , log_path , UTIL_PATH_SEP_CHAR , int_vector_iget( step_list , 0)); + else + log_file = util_alloc_sprintf("%s%c%04d-%04d" , log_path , UTIL_PATH_SEP_CHAR , int_vector_iget( step_list , 0) , int_vector_get_last( step_list )); + log_stream = util_fopen( log_file , "w" ); - enkf_obs_get_obs_and_measure( enkf_main->obs, - enkf_main_get_fs(enkf_main), - step_list , - FORECAST, - ens_size, - (const enkf_state_type **) enkf_main->ensemble, - meas_forecast, - obs_data , - obsset ); - - - enkf_analysis_deactivate_outliers( obs_data , meas_forecast , std_cutoff , alpha); - - if (enkf_main->verbose) - enkf_analysis_fprintf_obs_summary( obs_data , meas_forecast , step_list , local_ministep_get_name( ministep ) , stdout ); - enkf_analysis_fprintf_obs_summary( obs_data , meas_forecast , step_list , local_ministep_get_name( ministep ) , log_stream ); - - if (obs_data_get_active_size(obs_data) > 0) - enkf_main_analysis_update( enkf_main , - target_fs , - target_step , - use_count , - run_mode , - int_vector_get_first( step_list ), - current_step , - ministep , - meas_forecast , - obs_data ); - } - fclose( log_stream ); - - obs_data_free( obs_data ); - meas_data_free( meas_forecast ); - meas_data_free( meas_analyzed ); + free( log_file ); + } - enkf_main_inflate( enkf_main , target_fs , current_step , use_count); - hash_free( use_count ); + for (int ministep_nr = 0; ministep_nr < local_updatestep_get_num_ministep( updatestep ); ministep_nr++) { /* Looping over local analysis ministep */ + local_ministep_type * ministep = local_updatestep_iget_ministep( updatestep , ministep_nr ); + local_obsset_type * obsset = local_ministep_get_obsset( ministep ); + + obs_data_reset( obs_data ); + meas_data_reset( meas_forecast ); + + enkf_obs_get_obs_and_measure( enkf_main->obs, + source_fs , + step_list , + FORECAST, + ens_active_list , + (const enkf_state_type **) enkf_main->ensemble, + meas_forecast, + obs_data , + obsset ); + + + enkf_analysis_deactivate_outliers( obs_data , meas_forecast , std_cutoff , alpha); + + if (enkf_main->verbose) + enkf_analysis_fprintf_obs_summary( obs_data , meas_forecast , step_list , local_ministep_get_name( ministep ) , stdout ); + enkf_analysis_fprintf_obs_summary( obs_data , meas_forecast , step_list , local_ministep_get_name( ministep ) , log_stream ); + + if (obs_data_get_active_size(obs_data) > 0) + enkf_main_analysis_update( enkf_main , + target_fs , + ens_mask , + target_step , + use_count , + run_mode , + int_vector_get_first( step_list ), + current_step , + ministep , + meas_forecast , + obs_data ); + } + fclose( log_stream ); + + obs_data_free( obs_data ); + meas_data_free( meas_forecast ); + meas_data_free( meas_analyzed ); + + enkf_main_inflate( enkf_main , target_fs , current_step , use_count); + hash_free( use_count ); + + if (target_state_map != source_state_map) { + state_map_set_from_inverted_mask( target_state_map , ens_mask , STATE_PARENT_FAILURE); + enkf_fs_fsync( target_fs ); + } + } + bool_vector_free( ens_mask ); + int_vector_free( ens_active_list ); + return true; + } else { + fprintf(stderr,"** ERROR ** There are %d active realisations left, which is less than the minimum specified (%d) - stopping assimilation.\n" , + active_ens_size , + analysis_config_get_min_realisations(analysis_config)); + return false; } + } + void enkf_main_assimilation_update(enkf_main_type * enkf_main , const int_vector_type * step_list) { enkf_main_UPDATE( enkf_main , step_list , enkf_main_get_fs( enkf_main ) , int_vector_get_last( step_list ) , ENKF_ASSIMILATION ); } -void enkf_main_smoother_update(enkf_main_type * enkf_main , const int_vector_type * step_list , enkf_fs_type * target_fs) { - enkf_main_UPDATE( enkf_main , step_list , target_fs , 0 , SMOOTHER_UPDATE ); +bool enkf_main_smoother_update(enkf_main_type * enkf_main , const int_vector_type * step_list , enkf_fs_type * target_fs) { + return enkf_main_UPDATE( enkf_main , step_list , target_fs , 0 , SMOOTHER_UPDATE ); } @@ -1238,9 +1322,9 @@ static void enkf_main_report_load_failure( const enkf_main_type * enkf_main , in */ -static bool enkf_main_run_step(enkf_main_type * enkf_main , +static void enkf_main_run_step(enkf_main_type * enkf_main , run_mode_type run_mode , - const bool_vector_type * iactive , + bool_vector_type * iactive , int load_start , /* For internalizing results, and the first step in the update when merging. */ int init_step_parameter , state_enum init_state_parameter , @@ -1253,14 +1337,19 @@ static bool enkf_main_run_step(enkf_main_type * enkf_main , if (step1 > 0) ecl_config_assert_restart( enkf_main_get_ecl_config( enkf_main ) ); - + { + enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); bool verbose_queue = enkf_main->verbose; int max_internal_submit = model_config_get_max_internal_submit(enkf_main->model_config); const int ens_size = enkf_main_get_ensemble_size( enkf_main ); int job_size; int iens; + state_map_deselect_matching( enkf_fs_get_state_map( fs ) , iactive , STATE_LOAD_FAILURE | STATE_PARENT_FAILURE); + bool_vector_fprintf( iactive , stdout , "IACTIVE" , "%2d"); + + if (enkf_main->verbose) { if (run_mode == ENKF_ASSIMILATION) printf("Starting forward step: %d -> %d\n",step1 , step2); @@ -1347,10 +1436,10 @@ static bool enkf_main_run_step(enkf_main_type * enkf_main , subset (with offset > 0) of realisations are simulated. */ if (run_mode != INIT_ONLY) { bool totalOK = true; - for (iens = 0; iens < ens_size; iens++) { + for (iens = 0; iens < ens_size; iens++) { if (bool_vector_iget(iactive , iens)) { run_status_type run_status = enkf_state_get_simple_run_status( enkf_main->ensemble[iens] ); - + switch (run_status) { case JOB_RUN_FAILURE: enkf_main_report_run_failure( enkf_main , iens ); @@ -1373,9 +1462,7 @@ static bool enkf_main_run_step(enkf_main_type * enkf_main , if (run_mode != ENKF_ASSIMILATION) qc_module_run_workflow( enkf_main->qc_module , enkf_main ); } - return totalOK; - } else - return true; + } } } @@ -1439,18 +1526,21 @@ void enkf_main_init_run( enkf_main_type * enkf_main, run_mode_type run_mode) { void enkf_main_run_exp(enkf_main_type * enkf_main , - const bool_vector_type * iactive , + bool_vector_type * iactive , bool simulate , int init_step_parameters , int start_report , - state_enum start_state) { + state_enum start_state , + bool initialize) { bool force_init = false; int ens_size = enkf_main_get_ensemble_size( enkf_main ); run_mode_type run_mode = simulate ? ENSEMBLE_EXPERIMENT : INIT_ONLY; { stringlist_type * param_list = ensemble_config_alloc_keylist_from_var_type( enkf_main->ensemble_config , PARAMETER ); - enkf_main_initialize_from_scratch( enkf_main , param_list , 0 , ens_size - 1, force_init); + if(initialize) + enkf_main_initialize_from_scratch( enkf_main , param_list , 0 , ens_size - 1, force_init); + stringlist_free( param_list ); } enkf_main_init_run( enkf_main , run_mode ); @@ -1465,7 +1555,7 @@ void enkf_main_run_exp(enkf_main_type * enkf_main , void enkf_main_run_assimilation(enkf_main_type * enkf_main , - const bool_vector_type * iactive , + bool_vector_type * iactive , int init_step_parameters , int start_report , state_enum start_state) { @@ -1534,30 +1624,37 @@ void enkf_main_run_assimilation(enkf_main_type * enkf_main , if (load_start > 0) load_start++; + enkf_main_run_step(enkf_main , ENKF_ASSIMILATION , iactive , load_start , init_step_parameter , + init_state_parameter , init_state_dynamic , report_step1 , report_step2); { - bool runOK = enkf_main_run_step(enkf_main , ENKF_ASSIMILATION , iactive , load_start , init_step_parameter , - init_state_parameter , init_state_dynamic , report_step1 , report_step2); + enkf_fs_type * fs = enkf_main_get_fs(enkf_main); + state_map_type * state_map = enkf_fs_get_state_map(fs); + const analysis_config_type * analysis_config = enkf_main_get_analysis_config(enkf_main); + int active_ens_size = state_map_count_matching(state_map , STATE_HAS_DATA); - if (runOK) { + if (analysis_config_have_enough_realisations(analysis_config , active_ens_size)) { if (enkf_on) { bool merge_observations = analysis_config_get_merge_observations( enkf_main->analysis_config ); int_vector_type * step_list; int stride; - + if (merge_observations) stride = 1; else stride = 0; step_list = enkf_main_update_alloc_step_list( enkf_main , load_start , report_step2 , stride ); - + enkf_main_assimilation_update(enkf_main , step_list); int_vector_free( step_list ); enkf_fs_fsync( enkf_main->dbase ); } - } else - util_exit("Problems with the forward model - exiting.\n"); - + } else { + fprintf(stderr,"** ERROR ** There are %d active realisations left, which is less than the minimum specified (%d) - stopping assimilation.\n" , + active_ens_size , + analysis_config_get_min_realisations(analysis_config)); + break; + } prev_enkf_on = enkf_on; } } @@ -1578,17 +1675,18 @@ void enkf_main_run_smoother(enkf_main_type * enkf_main , const char * target_fs_ bool_vector_type * iactive = bool_vector_alloc( 0 , true ); bool_vector_iset( iactive , ens_size - 1 , true ); - enkf_main_init_run( enkf_main , ENSEMBLE_EXPERIMENT ); - if (enkf_main_run_step(enkf_main , ENSEMBLE_EXPERIMENT , iactive , 0 , 0 , ANALYZED , UNDEFINED , 0 , 0)) { + enkf_main_init_run( enkf_main , ENSEMBLE_EXPERIMENT); + enkf_main_run_step(enkf_main , ENSEMBLE_EXPERIMENT , iactive , 0 , 0 , ANALYZED , UNDEFINED , 0 , 0); + { + bool update_done; time_map_type * time_map = enkf_fs_get_time_map( enkf_main_get_fs( enkf_main )); enkf_fs_type * target_fs = enkf_main_get_alt_fs( enkf_main , target_fs_name , false , true ); { int stride = 1; int_vector_type * step_list = enkf_main_update_alloc_step_list( enkf_main , 0 , time_map_get_last_step( time_map ) , stride); - enkf_main_smoother_update( enkf_main , step_list , target_fs ); + update_done = enkf_main_smoother_update( enkf_main , step_list , target_fs ); int_vector_free( step_list ); } - enkf_main_set_fs( enkf_main , target_fs , target_fs_name); if (rerun) { /* @@ -1602,8 +1700,12 @@ void enkf_main_run_smoother(enkf_main_type * enkf_main , const char * target_fs_ active runpath for the remaining part of this program invocation. */ - model_config_select_runpath( enkf_main_get_model_config( enkf_main ) , RERUN_PATH_KEY ); - enkf_main_run_step(enkf_main , ENSEMBLE_EXPERIMENT , iactive , 0 , 0 , ANALYZED , UNDEFINED , 0 , 0 ); + if (update_done) { + enkf_main_set_fs( enkf_main , target_fs , target_fs_name); + model_config_select_runpath( enkf_main_get_model_config( enkf_main ) , RERUN_PATH_KEY ); + enkf_main_run_step(enkf_main , ENSEMBLE_EXPERIMENT , iactive , 0 , 0 , ANALYZED , UNDEFINED , 0 , 0 ); + } else + fprintf(stderr,"** Warning: the analysis update failed - no rerun started.\n"); } } @@ -1611,6 +1713,87 @@ void enkf_main_run_smoother(enkf_main_type * enkf_main , const char * target_fs_ } } +void enkf_main_iterate_smoother(enkf_main_type * enkf_main, int step2, int iteration_number, analysis_iter_config_type * iter_config, int_vector_type * step_list, bool_vector_type * iactive, model_config_type * model_config){ + const char * target_fs_name = analysis_iter_config_iget_case( iter_config , iteration_number+1 ); + const int ens_size = enkf_main_get_ensemble_size( enkf_main ); + const int step1 = 0; + if (target_fs_name == NULL){ + fprintf(stderr,"Sorry: the updated ensemble will overwrite the current case in the iterated ensemble smoother."); + enkf_main_smoother_update(enkf_main , step_list , enkf_main_get_fs(enkf_main)); + } + else{ + enkf_fs_type * target_fs = enkf_main_get_alt_fs(enkf_main , target_fs_name , false , true ); + enkf_main_smoother_update(enkf_main , step_list , target_fs ); + enkf_main_set_fs(enkf_main , target_fs , enkf_fs_get_case_name( target_fs )); + cases_config_set_int(enkf_fs_get_cases_config(target_fs), "iteration_number", iteration_number+1); + } + + bool_vector_iset( iactive , ens_size - 1 , true ); + const char * runpath_fmt = analysis_iter_config_iget_runpath_fmt( iter_config , iteration_number); + if (runpath_fmt != NULL) { + char * runpath_key = util_alloc_sprintf( "runpath-%d" , 999); + model_config_add_runpath( model_config , runpath_key , runpath_fmt); + model_config_select_runpath( model_config , runpath_key ); + free( runpath_key ); + } + + enkf_main_run_exp(enkf_main , iactive , true , step1 , step1 , FORECAST, false); +} + +void enkf_main_run_iterated_ES(enkf_main_type * enkf_main, int step2) { + { + const int ens_size = enkf_main_get_ensemble_size( enkf_main ); + model_config_type * model_config = enkf_main_get_model_config( enkf_main ); + const analysis_config_type * analysis_config = enkf_main_get_analysis_config( enkf_main ); + analysis_iter_config_type * iter_config = analysis_config_get_iter_config( analysis_config ); + const int step1 = 0; + int_vector_type * step_list = int_vector_alloc(0,0); + bool_vector_type * iactive = bool_vector_alloc(0 , true); + int iter = 0; + int num_iter = analysis_iter_config_get_num_iterations( iter_config ); + { + for (int step=step1; step <= step2; step++) + int_vector_append( step_list , step ); + } + bool_vector_iset( iactive , ens_size - 1 , true ); + const char * runpath_fmt = analysis_iter_config_iget_runpath_fmt( iter_config , iter); + if (runpath_fmt != NULL) { + char * runpath_key = util_alloc_sprintf( "runpath-%d" , iter); + model_config_add_runpath( model_config , runpath_key , runpath_fmt); + model_config_select_runpath( model_config , runpath_key ); + free( runpath_key ); + } + enkf_main_run_exp(enkf_main , iactive , true , step1 , step1 , FORECAST, true); + while (true) { + if (iter == num_iter) + break; + + enkf_main_iterate_smoother(enkf_main, step2, iter, iter_config, step_list, iactive, model_config); + iter++; + } + int_vector_free( step_list ); + bool_vector_free( iactive ); + } + +} + +void enkf_main_run_one_more_iteration(enkf_main_type * enkf_main, int step2) { + model_config_type * model_config = enkf_main_get_model_config( enkf_main ); + const analysis_config_type * analysis_config = enkf_main_get_analysis_config( enkf_main ); + analysis_iter_config_type * iter_config = analysis_config_get_iter_config( analysis_config ); + enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); + cases_config_type * case_config = enkf_fs_get_cases_config( fs ); + int iteration_number = cases_config_get_iteration_number( case_config ); + const int step1 = 0; + int_vector_type * step_list = int_vector_alloc(0,0); + bool_vector_type * iactive = bool_vector_alloc(0 , true); + + { + for (int step=step1; step <= step2; step++) + int_vector_append( step_list , step ); + } + enkf_main_iterate_smoother(enkf_main, step2, iteration_number, iter_config, step_list, iactive, model_config); +} /*****************************************************************/ /* Filesystem copy functions */ @@ -1702,9 +1885,15 @@ void enkf_main_initialize_from_existing__(enkf_main_type * enkf_main , const char * target_case = NULL; enkf_main_copy_ensemble(enkf_main , - source_case , source_report_step , source_state , - target_case , target_report_step , target_state , - iens_mask , ranking_key , node_list); + source_case , + source_report_step , + source_state , + target_case , + target_report_step , + target_state , + iens_mask , + ranking_key , + node_list); } @@ -2131,7 +2320,7 @@ enkf_main_type * enkf_main_alloc_empty( ) { enkf_main->plot_config = plot_config_alloc_default(); enkf_main->ranking_table = ranking_table_alloc( 0 ); enkf_main->obs = enkf_obs_alloc( ); - enkf_main->model_config = model_config_alloc_empty( ); + enkf_main->model_config = model_config_alloc( ); enkf_main_rng_init( enkf_main ); enkf_main->subst_func_pool = subst_func_pool_alloc( ); @@ -2139,7 +2328,7 @@ enkf_main_type * enkf_main_alloc_empty( ) { enkf_main->templates = ert_templates_alloc( enkf_main->subst_list ); enkf_main->workflow_list = ert_workflow_list_alloc( enkf_main->subst_list ); enkf_main->qc_module = qc_module_alloc( enkf_main->workflow_list , DEFAULT_QC_PATH ); - enkf_main->analysis_config = analysis_config_alloc_default( enkf_main->rng ); + enkf_main->analysis_config = analysis_config_alloc( enkf_main->rng ); enkf_main->report_list = ert_report_list_alloc( DEFAULT_REPORT_PATH , plot_config_get_path( enkf_main->plot_config ) ); enkf_main_init_subst_list( enkf_main ); diff --git a/ThirdParty/Ert/devel/libenkf/src/enkf_main_jobs.c b/ThirdParty/Ert/devel/libenkf/src/enkf_main_jobs.c index b993d5f99a..98944dbb44 100644 --- a/ThirdParty/Ert/devel/libenkf/src/enkf_main_jobs.c +++ b/ThirdParty/Ert/devel/libenkf/src/enkf_main_jobs.c @@ -48,7 +48,7 @@ void * enkf_main_ensemble_run_JOB( void * self , const stringlist_type * args ) // if (stringlist_get_size( args ) bool_vector_iset( iactive , ens_size - 1 , true ); - enkf_main_run_exp( enkf_main , iactive , true , 0 , 0 , ANALYZED ); + enkf_main_run_exp( enkf_main , iactive , true , 0 , 0 , ANALYZED , true); return NULL; } diff --git a/ThirdParty/Ert/devel/libenkf/src/enkf_obs.c b/ThirdParty/Ert/devel/libenkf/src/enkf_obs.c index 7c0d65907b..6dce4f6965 100644 --- a/ThirdParty/Ert/devel/libenkf/src/enkf_obs.c +++ b/ThirdParty/Ert/devel/libenkf/src/enkf_obs.c @@ -261,19 +261,19 @@ obs_vector_type * enkf_obs_get_vector(const enkf_obs_type * obs, const char * ke -void enkf_obs_get_obs_and_measure_summary(const enkf_obs_type * enkf_obs, - obs_vector_type * obs_vector , - enkf_fs_type * fs, - const int_vector_type * step_list , - state_enum state, - int ens_size, - const enkf_state_type ** ensemble , - meas_data_type * meas_data, - obs_data_type * obs_data, - const local_obsset_type * obsset , - double_vector_type * obs_value , - double_vector_type * obs_std) { - +static void enkf_obs_get_obs_and_measure_summary(const enkf_obs_type * enkf_obs, + obs_vector_type * obs_vector , + enkf_fs_type * fs, + const int_vector_type * step_list , + state_enum state, + const int_vector_type * ens_active_list , + const enkf_state_type ** ensemble , + meas_data_type * meas_data, + obs_data_type * obs_data, + const local_obsset_type * obsset , + double_vector_type * obs_value , + double_vector_type * obs_std) { + const active_list_type * active_list = local_obsset_get_obs_active_list( obsset , obs_vector_get_obs_key( obs_vector )); matrix_type * error_covar = NULL; int active_count = 0; @@ -353,16 +353,20 @@ void enkf_obs_get_obs_and_measure_summary(const enkf_obs_type * enkf_obs, int step = int_vector_iget( step_list , i ); if (obs_vector_iget_active( obs_vector , step ) && active_list_iget( active_list , 0 /* Index into the scalar summary observation */)) { - int iens; - for (iens = 0; iens < ens_size; iens++) { + for (int iens_index = 0; iens_index < int_vector_size( ens_active_list ); iens_index++) { + const int iens = int_vector_iget( ens_active_list , iens_index ); const char * state_key = obs_vector_get_state_kw(obs_vector); enkf_node_type * enkf_node = enkf_state_get_node(ensemble[iens] , state_key); node_id_type node_id = {.report_step = step, - .iens = iens, + .iens = iens , .state = state }; - + enkf_node_load( enkf_node , fs , node_id ); - meas_block_iset(meas_block , iens , active_count , summary_get( enkf_node_value_ptr( enkf_node ) , node_id.report_step , node_id.state )); + + meas_block_iset(meas_block , + iens_index , active_count , + summary_get( enkf_node_value_ptr( enkf_node ) , node_id.report_step , node_id.state )); + } active_count++; } @@ -385,7 +389,7 @@ void enkf_obs_get_obs_and_measure(const enkf_obs_type * enkf_obs, enkf_fs_type * fs, const int_vector_type * step_list , state_enum state, - int ens_size, + const int_vector_type * ens_active_list , const enkf_state_type ** ensemble , meas_data_type * meas_data, obs_data_type * obs_data, @@ -406,7 +410,7 @@ void enkf_obs_get_obs_and_measure(const enkf_obs_type * enkf_obs, fs , step_list , state , - ens_size , + ens_active_list , ensemble , meas_data , obs_data , @@ -420,14 +424,10 @@ void enkf_obs_get_obs_and_measure(const enkf_obs_type * enkf_obs, if (obs_vector_iget_active(obs_vector , report_step)) { /* The observation is active for this report step. */ const active_list_type * active_list = local_obsset_get_obs_active_list( obsset , obs_key ); obs_vector_iget_observations(obs_vector , report_step , obs_data , active_list); /* Collect the observed data in the obs_data instance. */ - { - /* Could be multithreaded */ - int iens; - for (iens = 0; iens < ens_size; iens++) { - - obs_vector_measure(obs_vector , fs , state , report_step , ensemble[iens] , meas_data , active_list); - - } + /* Could be multithreaded */ + for (int iens_index = 0; iens_index < int_vector_size( ens_active_list ); iens_index++) { + const int iens = int_vector_iget( ens_active_list , iens_index ); + obs_vector_measure(obs_vector , fs , state , report_step , iens_index , ensemble[iens] , meas_data , active_list); } } } diff --git a/ThirdParty/Ert/devel/libenkf/src/enkf_state.c b/ThirdParty/Ert/devel/libenkf/src/enkf_state.c index 3453705a68..9a233cfcda 100644 --- a/ThirdParty/Ert/devel/libenkf/src/enkf_state.c +++ b/ThirdParty/Ert/devel/libenkf/src/enkf_state.c @@ -70,6 +70,7 @@ #include #include #include +#include #define ENKF_STATE_TYPE_ID 78132 @@ -280,16 +281,29 @@ static void shared_info_free(shared_info_type * shared_info) { /*****************************************************************/ void enkf_state_initialize(enkf_state_type * enkf_state , enkf_fs_type * fs , const stringlist_type * param_list, bool force_init) { - state_enum init_state = ANALYZED; - int ip; - for (ip = 0; ip < stringlist_get_size(param_list); ip++) { - int iens = enkf_state_get_iens( enkf_state ); - enkf_node_type * param_node = enkf_state_get_node( enkf_state , stringlist_iget( param_list , ip)); - node_id_type node_id = {.report_step = 0, .iens = iens , .state = init_state }; - if (force_init || (enkf_node_has_data( param_node , fs , node_id) == false)) { - if (enkf_node_initialize( param_node , iens , enkf_state->rng)) - enkf_node_store( param_node , fs , true , node_id); + int iens = enkf_state_get_iens( enkf_state ); + state_map_type * state_map = enkf_fs_get_state_map( fs ); + realisation_state_enum current_state = state_map_iget(state_map, iens); + if ((current_state == STATE_PARENT_FAILURE) && (force_init == false)) + return; + else { + state_enum init_state = ANALYZED; + + for (int ip = 0; ip < stringlist_get_size(param_list); ip++) + { + enkf_node_type * param_node = enkf_state_get_node(enkf_state, stringlist_iget(param_list, ip)); + node_id_type node_id = { .report_step = 0, .iens = iens, .state = init_state }; + bool has_data = enkf_node_has_data(param_node, fs, node_id); + + if (force_init || (has_data == false) || (current_state == STATE_LOAD_FAILURE)) + { + if (enkf_node_initialize(param_node, iens, enkf_state->rng)) { + enkf_node_store(param_node, fs, true, node_id); + state_map_iset(state_map , iens , STATE_INITIALIZED); + } + } } + enkf_fs_fsync(fs); } } @@ -588,7 +602,7 @@ const char * enkf_state_get_eclbase( const enkf_state_type * enkf_state ) { } -static ecl_sum_type * enkf_state_load_ecl_sum(const enkf_state_type * enkf_state , stringlist_type * messages , bool * loadOK) { +static ecl_sum_type * enkf_state_load_ecl_sum(const enkf_state_type * enkf_state , stringlist_type * messages , int * result) { const run_info_type * run_info = enkf_state->run_info; const ecl_config_type * ecl_config = enkf_state->shared_info->ecl_config; const bool fmt_file = ecl_config_get_formatted(ecl_config); @@ -650,7 +664,7 @@ static ecl_sum_type * enkf_state_load_ecl_sum(const enkf_state_type * enkf_state } ecl_sum_free( summary ); summary = NULL; - *loadOK = false; + *result |= LOAD_FAILURE; } } } @@ -674,8 +688,21 @@ static void enkf_state_log_GEN_DATA_load( const enkf_node_type * enkf_node , int } +static bool enkf_state_report_step_compatible(const enkf_state_type * enkf_state, const ecl_sum_type * ecl_sum_simulated) { + bool ret = true; -static bool enkf_state_internalize_dynamic_eclipse_results(enkf_state_type * enkf_state , enkf_fs_type * fs , const model_config_type * model_config , bool * loadOK, bool interactive , stringlist_type * msg_list) { + const model_config_type * model_config = enkf_state->shared_info->model_config; + const ecl_sum_type * ecl_sum_reference = model_config_get_refcase(model_config); + + if (ecl_sum_reference) //Can be NULL + ret = ecl_sum_report_step_compatible(ecl_sum_reference, ecl_sum_simulated); + + return ret; +} + + + +static bool enkf_state_internalize_dynamic_eclipse_results(enkf_state_type * enkf_state , enkf_fs_type * fs , const model_config_type * model_config , int * result, bool interactive , stringlist_type * msg_list) { const run_info_type * run_info = enkf_state->run_info; int load_start = run_info->load_start; @@ -684,10 +711,16 @@ static bool enkf_state_internalize_dynamic_eclipse_results(enkf_state_type * enk { /* Looking for summary files on disk, and loading them. */ - ecl_sum_type * summary = enkf_state_load_ecl_sum( enkf_state , msg_list , loadOK ); + ecl_sum_type * summary = enkf_state_load_ecl_sum( enkf_state , msg_list , result ); /** OK - now we have actually loaded the ecl_sum instance, or ecl_sum == NULL. */ if (summary != NULL) { + + /*Check the loaded summary against the reference ecl_sum_type */ + if (!enkf_state_report_step_compatible(enkf_state, summary)) + *result |= REPORT_STEP_INCOMPATIBLE; + + /* The actual loading internalizing - from ecl_sum -> enkf_node. */ const shared_info_type * shared_info = enkf_state->shared_info; const int iens = member_config_get_iens( enkf_state->my_config ); @@ -708,7 +741,7 @@ static bool enkf_state_internalize_dynamic_eclipse_results(enkf_state_type * enk if (interactive && enkf_node_get_impl_type(node) == GEN_DATA) enkf_state_log_GEN_DATA_load( node , 0 , msg_list ); } else { - *loadOK = false; + *result |= LOAD_FAILURE; log_add_fmt_message(shared_info->logh , 3 , NULL , "[%03d:----] Failed to load data for vector node:%s.",iens , enkf_node_get_key( node )); if (interactive) stringlist_append_owned_ref( msg_list , util_alloc_sprintf("Failed to load vector:%s" , enkf_node_get_key( node ))); @@ -723,7 +756,7 @@ static bool enkf_state_internalize_dynamic_eclipse_results(enkf_state_type * enk if (interactive && enkf_node_get_impl_type(node) == GEN_DATA) enkf_state_log_GEN_DATA_load( node , report_step , msg_list ); } else { - *loadOK = false; + *result |= LOAD_FAILURE; log_add_fmt_message(shared_info->logh , 3 , NULL , "[%03d:%04d] Failed to load data for node:%s.",iens , report_step , enkf_node_get_key( node )); if (interactive) stringlist_append_owned_ref( msg_list , util_alloc_sprintf("Failed to load node:%s at step:%d" , enkf_node_get_key( node ) , report_step)); @@ -747,11 +780,11 @@ static bool enkf_state_internalize_dynamic_eclipse_results(enkf_state_type * enk } -static bool enkf_state_internalize_dynamic_results(enkf_state_type * enkf_state , enkf_fs_type * fs , const model_config_type * model_config , bool * loadOK, bool interactive , stringlist_type * msg_list) { +static bool enkf_state_internalize_dynamic_results(enkf_state_type * enkf_state , enkf_fs_type * fs , const model_config_type * model_config , int * result, bool interactive , stringlist_type * msg_list) { const ecl_config_type * ecl_config = enkf_state->shared_info->ecl_config; if (ecl_config_active( ecl_config )) { - bool eclipse_load = enkf_state_internalize_dynamic_eclipse_results( enkf_state , fs , model_config , loadOK, interactive , msg_list); + bool eclipse_load = enkf_state_internalize_dynamic_eclipse_results( enkf_state , fs , model_config , result, interactive , msg_list); if (!eclipse_load) fprintf(stderr , "** Warning: could not load ECLIPSE summary data from %s - this will probably fail later ...\n" , enkf_state->run_info->run_path); return eclipse_load; @@ -795,7 +828,7 @@ static char * __realloc_static_kw(char * kw , int occurence) { When the state has been loaded it goes straight to disk. */ -static void enkf_state_internalize_eclipse_state(enkf_state_type * enkf_state , enkf_fs_type * fs , const model_config_type * model_config , int report_step , bool store_vectors , bool * loadOK , bool interactive , stringlist_type * msg_list) { +static void enkf_state_internalize_eclipse_state(enkf_state_type * enkf_state , enkf_fs_type * fs , const model_config_type * model_config , int report_step , bool store_vectors , int * result, bool interactive , stringlist_type * msg_list) { member_config_type * my_config = enkf_state->my_config; shared_info_type * shared_info = enkf_state->shared_info; run_info_type * run_info = enkf_state->run_info; @@ -964,7 +997,7 @@ static void enkf_state_internalize_eclipse_state(enkf_state_type * enkf_state , } else { if (enkf_node_get_impl_type(enkf_node) != GEN_DATA) { - *loadOK = false; + *result |= LOAD_FAILURE; log_add_fmt_message(shared_info->logh , 1 , NULL , "[%03d:%04d] Failed load data for node:%s.",iens , report_step , enkf_node_get_key( enkf_node )); if (interactive) @@ -989,14 +1022,14 @@ static void enkf_state_internalize_state(enkf_state_type * enkf_state , const model_config_type * model_config , int report_step , bool store_vectors , - bool * loadOK , + int * result , bool interactive , stringlist_type * msg_list) { const ecl_config_type * ecl_config = enkf_state->shared_info->ecl_config; if (ecl_config_active( ecl_config )) - enkf_state_internalize_eclipse_state( enkf_state , fs , model_config , report_step , store_vectors , loadOK , interactive , msg_list); + enkf_state_internalize_eclipse_state( enkf_state , fs , model_config , report_step , store_vectors , result , interactive , msg_list); } @@ -1011,7 +1044,7 @@ static void enkf_state_internalize_state(enkf_state_type * enkf_state , */ -static void enkf_state_internalize_results(enkf_state_type * enkf_state , enkf_fs_type * fs , bool * loadOK , bool interactive , stringlist_type * msg_list) { +static void enkf_state_internalize_results(enkf_state_type * enkf_state , enkf_fs_type * fs ,int * result , bool interactive , stringlist_type * msg_list) { run_info_type * run_info = enkf_state->run_info; model_config_type * model_config = enkf_state->shared_info->model_config; int report_step; @@ -1022,7 +1055,7 @@ static void enkf_state_internalize_results(enkf_state_type * enkf_state , enkf_f hence we must load the summary results first. */ - if (enkf_state_internalize_dynamic_results(enkf_state , fs , model_config , loadOK, interactive , msg_list)) { + if (enkf_state_internalize_dynamic_results(enkf_state , fs , model_config , result, interactive , msg_list)) { int last_report = time_map_get_last_step( enkf_fs_get_time_map( fs )); /* @@ -1038,7 +1071,7 @@ static void enkf_state_internalize_results(enkf_state_type * enkf_state , enkf_f bool store_vectors = (report_step == last_report) ? true : false; if (model_config_load_state( model_config , report_step)) - enkf_state_internalize_state(enkf_state , fs , model_config , report_step , store_vectors , loadOK , interactive , msg_list); + enkf_state_internalize_state(enkf_state , fs , model_config , report_step , store_vectors , result , interactive , msg_list); } } } @@ -1046,7 +1079,7 @@ static void enkf_state_internalize_results(enkf_state_type * enkf_state , enkf_f void enkf_state_forward_init(enkf_state_type * enkf_state , enkf_fs_type * fs , - bool * loadOK ) { + int * result ) { run_info_type * run_info = enkf_state->run_info; if (run_info->step1 == 0) { @@ -1068,7 +1101,7 @@ void enkf_state_forward_init(enkf_state_type * enkf_state , if (enkf_node_forward_init(node , run_info->run_path , iens )) enkf_node_store( node , fs, false , node_id ); else - *loadOK = false; + *result |= LOAD_FAILURE; } } @@ -1082,14 +1115,22 @@ void enkf_state_forward_init(enkf_state_type * enkf_state , void enkf_state_load_from_forward_model(enkf_state_type * enkf_state , enkf_fs_type * fs , - bool * loadOK , + int * result, bool interactive , stringlist_type * msg_list) { if (ensemble_config_have_forward_init( enkf_state->ensemble_config )) - enkf_state_forward_init( enkf_state , fs , loadOK ); + enkf_state_forward_init( enkf_state , fs , result ); - enkf_state_internalize_results( enkf_state , fs , loadOK , interactive , msg_list ); + enkf_state_internalize_results( enkf_state , fs , result , interactive , msg_list ); + { + state_map_type * state_map = enkf_fs_get_state_map( fs ); + int iens = member_config_get_iens( enkf_state->my_config ); + if (*result & LOAD_FAILURE) + state_map_iset( state_map , iens , STATE_LOAD_FAILURE); + else + state_map_iset( state_map , iens , STATE_HAS_DATA); + } } @@ -1107,23 +1148,28 @@ void * enkf_state_load_from_forward_model_mt( void * arg ) { int step2 = arg_pack_iget_int( arg_pack , 4 ); bool interactive = arg_pack_iget_bool( arg_pack , 5 ); stringlist_type * msg_list = arg_pack_iget_ptr( arg_pack , 6 ); - bool loadOK = true; - + int iens = member_config_get_iens( enkf_state->my_config ); + int result = 0; run_info_init_for_load( enkf_state->run_info , load_start , step1 , step2 , - member_config_get_iens( enkf_state->my_config ) , + iens , model_config_get_runpath_fmt( enkf_state->shared_info->model_config ) , enkf_state->subst_list ); - enkf_state_load_from_forward_model( enkf_state , fs , &loadOK , interactive , msg_list ); + enkf_state_load_from_forward_model( enkf_state , fs , &result , interactive , msg_list ); + if (result & REPORT_STEP_INCOMPATIBLE) { + // If refcase has been used for observations: crash and burn. + fprintf(stderr,"** Warning the timesteps in refcase and current simulation are not in accordance - something wrong with schedule file?\n"); + result -= REPORT_STEP_INCOMPATIBLE; + } + if (interactive) { printf("."); fflush(stdout); } - return NULL; } @@ -1305,7 +1351,7 @@ void enkf_state_fread(enkf_state_type * enkf_state , enkf_fs_type * fs , int mas if (enkf_node_include_type(enkf_node , mask)) { node_id_type node_id = {.report_step = report_step , .iens = member_config_get_iens( my_config ) , - state = state }; + .state = state }; bool forward_init = enkf_node_use_forward_init( enkf_node ); if (forward_init) enkf_node_try_load(enkf_node , fs , node_id ); @@ -1940,7 +1986,7 @@ static bool enkf_state_complete_forward_modelOK(enkf_state_type * enkf_state , e run_info_type * run_info = enkf_state->run_info; const member_config_type * my_config = enkf_state->my_config; const int iens = member_config_get_iens( my_config ); - bool loadOK = true; + int result = 0; /** @@ -1950,8 +1996,16 @@ static bool enkf_state_complete_forward_modelOK(enkf_state_type * enkf_state , e is OK the final status is updated, otherwise: restart. */ log_add_fmt_message( shared_info->logh , 2 , NULL , "[%03d:%04d-%04d] Forward model complete - starting to load results." , iens , run_info->step1, run_info->step2); - enkf_state_load_from_forward_model(enkf_state , fs , &loadOK , false , NULL); - if (loadOK) { + enkf_state_load_from_forward_model(enkf_state , fs , &result , false , NULL); + + if (result & REPORT_STEP_INCOMPATIBLE) { + // If refcase has been used for observations: crash and burn. + fprintf(stderr,"** Warning the timesteps in refcase and current simulation are not in accordance - something wrong with schedule file?\n"); + result -= REPORT_STEP_INCOMPATIBLE; + } + + + if (0 == result) { /* The loading succeded - so this is a howling success! We set the main status to JOB_QUEUE_ALL_OK and inform the queue layer @@ -1965,7 +2019,7 @@ static bool enkf_state_complete_forward_modelOK(enkf_state_type * enkf_state , e run_info->__ready = false; /* Setting it to false - for the next round ??? */ run_info_complete_run(enkf_state->run_info); /* free() on runpath */ } - return loadOK; + return (0 == result) ? true : false; } @@ -1992,7 +2046,11 @@ static bool enkf_state_complete_forward_modelEXIT(enkf_state_type * enkf_state , log_add_fmt_message( shared_info->logh , 1 , NULL , "[%03d:%04d-%04d] FAILED COMPLETELY." , iens , run_info->step1, run_info->step2); if (run_info->run_status != JOB_LOAD_FAILURE) run_info->run_status = JOB_RUN_FAILURE; - + { + state_map_type * state_map = enkf_fs_get_state_map( fs ); + int iens = member_config_get_iens( enkf_state->my_config ); + state_map_iset( state_map , iens , STATE_LOAD_FAILURE ); + } return false; } } diff --git a/ThirdParty/Ert/devel/libenkf/src/meas_data.c b/ThirdParty/Ert/devel/libenkf/src/meas_data.c index c3b12579df..5c4d5a7be8 100644 --- a/ThirdParty/Ert/devel/libenkf/src/meas_data.c +++ b/ThirdParty/Ert/devel/libenkf/src/meas_data.c @@ -26,18 +26,22 @@ #include #include +#include #include #include #include #include #include +#include #include #define MEAS_BLOCK_TYPE_ID 661936407 +#define MEAS_DATA_TYPE_ID 561000861 struct meas_data_struct { + UTIL_TYPE_ID_DECLARATION; int ens_size; vector_type * data; pthread_mutex_t data_mutex; @@ -146,15 +150,6 @@ static void meas_data_assign_block( meas_block_type * target_block , const meas_ } } -static void meas_block_memcpy( meas_block_type * target_block , const meas_block_type * src_block) { - if (target_block->data_size != src_block->data_size) - util_abort("%s: size mismatch. target:%d src:%d \n",__func__ , target_block->data_size , src_block->data_size ); - - memcpy( target_block->data , src_block->data , src_block->data_size * sizeof * src_block->data ); - memcpy( target_block->active , src_block->active , src_block->obs_size * sizeof * src_block->active ); -} - - void meas_block_calculate_ens_stats( meas_block_type * meas_block ) { bool include_inactive = true; @@ -222,18 +217,23 @@ int meas_block_get_total_size( const meas_block_type * meas_block ) { /*****************************************************************/ +UTIL_IS_INSTANCE_FUNCTION( meas_data , MEAS_DATA_TYPE_ID ) -meas_data_type * meas_data_alloc(int ens_size) { - meas_data_type * meas = util_malloc(sizeof * meas ); +meas_data_type * meas_data_alloc( const int_vector_type * ens_active_list ) { + int ens_size = int_vector_size( ens_active_list ); if (ens_size <= 0) util_abort("%s: ens_size must be > 0 - aborting \n",__func__); - - meas->ens_size = ens_size; - meas->data = vector_alloc_new(); - meas->lookup_keys = set_alloc_empty(); - pthread_mutex_init( &meas->data_mutex , NULL ); - - return meas; + { + meas_data_type * meas = util_malloc(sizeof * meas ); + UTIL_TYPE_ID_INIT( meas , MEAS_DATA_TYPE_ID ); + + meas->ens_size = ens_size; + meas->data = vector_alloc_new(); + meas->lookup_keys = set_alloc_empty(); + pthread_mutex_init( &meas->data_mutex , NULL ); + + return meas; + } } @@ -324,21 +324,6 @@ void meas_data_assign_vector(meas_data_type * target_matrix, const meas_data_typ } -meas_data_type * meas_data_alloc_copy( const meas_data_type * src_matrix ) { - meas_data_type * copy_matrix = meas_data_alloc( src_matrix->ens_size ); - - for (int block_nr = 0; block_nr < vector_get_size( src_matrix->data ); block_nr++) { - const meas_block_type * src_block = meas_data_iget_block_const( src_matrix , block_nr ); - meas_data_add_block( copy_matrix , src_block->obs_key , src_block->report_step , src_block->obs_size ); - { - meas_block_type * copy_block = meas_data_iget_block( copy_matrix , block_nr ); - meas_block_memcpy( copy_block , src_block ); - } - } - - return copy_matrix; -} - void meas_data_fprintf( const meas_data_type * matrix , FILE * stream ) { diff --git a/ThirdParty/Ert/devel/libenkf/src/model_config.c b/ThirdParty/Ert/devel/libenkf/src/model_config.c index a8f1faa12f..209f002c14 100644 --- a/ThirdParty/Ert/devel/libenkf/src/model_config.c +++ b/ThirdParty/Ert/devel/libenkf/src/model_config.c @@ -22,6 +22,7 @@ #include #include +#include #include #include #include @@ -73,12 +74,15 @@ only options visible to the user. */ +#define MODEL_CONFIG_TYPE_ID 661053 struct model_config_struct { + UTIL_TYPE_ID_DECLARATION; stringlist_type * case_names; /* A list of "iens -> name" mappings - can be NULL. */ char * case_table_file; forward_model_type * forward_model; /* The forward_model - as loaded from the config file. Each enkf_state object internalizes its private copy of the forward_model. */ history_type * history; /* The history object. */ path_fmt_type * current_runpath; /* path_fmt instance for runpath - runtime the call gets arguments: (iens, report_step1 , report_step2) - i.e. at least one %d must be present.*/ + char * current_path_key; hash_type * runpath_map; char * jobname_fmt; /* Format string with one '%d' for the jobname - can be NULL in which case the eclbase name will be used. */ enkf_sched_type * enkf_sched; /* The enkf_sched object controlling when the enkf is ON|OFF, strides in report steps and special forward model - allocated on demand - right before use. */ @@ -170,6 +174,7 @@ void model_config_add_runpath( model_config_type * model_config , const char * p bool model_config_select_runpath( model_config_type * model_config , const char * path_key) { if (hash_has_key( model_config->runpath_map , path_key )) { model_config->current_runpath = hash_get( model_config->runpath_map , path_key ); + model_config->current_path_key = util_realloc_string_copy( model_config->current_path_key , path_key); return true; } else { if (model_config->current_runpath != NULL) // OK - we already have a valid selection - stick to that and return False. @@ -182,6 +187,16 @@ bool model_config_select_runpath( model_config_type * model_config , const char } +void model_config_set_runpath(model_config_type * model_config , const char * fmt) { + if (model_config->current_path_key) { + model_config_add_runpath(model_config , model_config->current_path_key , fmt); + model_config_select_runpath( model_config , model_config->current_path_key ); + } else + util_abort("%s: current path has not been set \n",__func__); +} + + + /** This function is not called at bootstrap time, but rather as part of an initialization just before the run. Can be called maaaanye @@ -241,6 +256,9 @@ fs_driver_impl model_config_get_dbase_type(const model_config_type * model_confi return model_config->dbase_type; } +const ecl_sum_type * model_config_get_refcase( const model_config_type * model_config ) { + return model_config->refcase; +} void * model_config_get_dbase_args( const model_config_type * model_config ) { return NULL; @@ -291,8 +309,9 @@ void model_config_set_max_internal_submit( model_config_type * model_config , in } +UTIL_IS_INSTANCE_FUNCTION( model_config , MODEL_CONFIG_TYPE_ID) -model_config_type * model_config_alloc_empty() { +model_config_type * model_config_alloc() { model_config_type * model_config = util_malloc(sizeof * model_config ); /** There are essentially three levels of initialisation: @@ -302,11 +321,13 @@ model_config_type * model_config_alloc_empty() { 3. Initialize with user supplied values. */ + UTIL_TYPE_ID_INIT(model_config , MODEL_CONFIG_TYPE_ID); model_config->case_names = NULL; model_config->enspath = NULL; model_config->rftpath = NULL; model_config->dbase_type = INVALID_DRIVER_ID; model_config->current_runpath = NULL; + model_config->current_path_key = NULL; model_config->enkf_sched = NULL; model_config->enkf_sched_file = NULL; model_config->case_table_file = NULL; @@ -476,6 +497,7 @@ void model_config_free(model_config_type * model_config) { util_safe_free( model_config->enkf_sched_file ); util_safe_free( model_config->select_case ); util_safe_free( model_config->case_table_file ); + util_safe_free( model_config->current_path_key); if (model_config->history != NULL) history_free(model_config->history); diff --git a/ThirdParty/Ert/devel/libenkf/src/obs_vector.c b/ThirdParty/Ert/devel/libenkf/src/obs_vector.c index 7d32b64f84..dcf610d846 100644 --- a/ThirdParty/Ert/devel/libenkf/src/obs_vector.c +++ b/ThirdParty/Ert/devel/libenkf/src/obs_vector.c @@ -756,7 +756,14 @@ void obs_vector_iget_observations(const obs_vector_type * obs_vector , int repor } -void obs_vector_measure(const obs_vector_type * obs_vector , enkf_fs_type * fs , state_enum state , int report_step , const enkf_state_type * enkf_state , meas_data_type * meas_data , const active_list_type * active_list) { +void obs_vector_measure(const obs_vector_type * obs_vector , + enkf_fs_type * fs , + state_enum state , + int report_step , + int active_iens_index , + const enkf_state_type * enkf_state , + meas_data_type * meas_data , + const active_list_type * active_list) { void * obs_node = vector_iget( obs_vector->nodes , report_step ); if ( obs_node != NULL ) { @@ -766,6 +773,7 @@ void obs_vector_measure(const obs_vector_type * obs_vector , enkf_fs_type * fs , .iens = enkf_state_get_iens( enkf_state ) }; enkf_node_load(enkf_node , fs , node_id); + node_id.iens = active_iens_index; obs_vector->measure(obs_node , enkf_node_value_ptr(enkf_node) , node_id , meas_data , active_list); } } diff --git a/ThirdParty/Ert/devel/libenkf/src/state_map.c b/ThirdParty/Ert/devel/libenkf/src/state_map.c new file mode 100644 index 0000000000..3c5d03102b --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/src/state_map.c @@ -0,0 +1,245 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + The file 'state_map.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ + + +#define _GNU_SOURCE /* Must define this to get access to pthread_rwlock_t */ +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + + +#define STATE_MAP_TYPE_ID 500672132 + +struct state_map_struct { + UTIL_TYPE_ID_DECLARATION; + int_vector_type * state; + pthread_rwlock_t rw_lock; +}; + + +UTIL_IS_INSTANCE_FUNCTION( state_map , STATE_MAP_TYPE_ID ) + + +state_map_type * state_map_alloc( ) { + state_map_type * map = util_malloc( sizeof * map ); + UTIL_TYPE_ID_INIT( map , STATE_MAP_TYPE_ID ); + map->state = int_vector_alloc( 0 , STATE_UNDEFINED ); + pthread_rwlock_init( &map->rw_lock , NULL); + return map; +} + + +state_map_type * state_map_fread_alloc( const char * filename ) { + state_map_type * map = state_map_alloc(); + if (util_file_exists( filename )) { + FILE * stream = util_fopen( filename , "r"); + int_vector_fread( map->state , stream ); + fclose( stream ); + } + return map; +} + +state_map_type * state_map_alloc_copy( state_map_type * map ) { + state_map_type * copy = state_map_alloc(); + pthread_rwlock_rdlock( &map->rw_lock ); + { + int_vector_memcpy( copy->state , map->state ); + } + pthread_rwlock_unlock( &map->rw_lock ); + return copy; +} + +void state_map_free( state_map_type * map ) { + free( map ); +} + + +int state_map_get_size( state_map_type * map) { + int size; + pthread_rwlock_rdlock( &map->rw_lock ); + { + size = int_vector_size( map->state ); + } + pthread_rwlock_unlock( &map->rw_lock ); + return size; +} + + +bool state_map_equal( state_map_type * map1 , state_map_type * map2) { + bool equal = true; + pthread_rwlock_rdlock( &map1->rw_lock ); + pthread_rwlock_rdlock( &map2->rw_lock ); + { + if (int_vector_size( map1->state) != int_vector_size( map2->state)) + equal = false; + + if (equal) + equal = int_vector_equal( map1->state , map2->state ); + } + pthread_rwlock_unlock( &map1->rw_lock ); + pthread_rwlock_unlock( &map2->rw_lock ); + return equal; +} + + +realisation_state_enum state_map_iget( state_map_type * map , int index) { + realisation_state_enum state; + pthread_rwlock_rdlock( &map->rw_lock ); + { + state = int_vector_safe_iget( map->state , index ); + } + pthread_rwlock_unlock( &map->rw_lock ); + return state; +} + +static void state_map_iset__( state_map_type * map , int index , realisation_state_enum new_state) { + realisation_state_enum current_state = int_vector_safe_iget( map->state , index ); + int target_mask = 0; + + if (current_state == STATE_UNDEFINED) + target_mask = STATE_INITIALIZED | STATE_PARENT_FAILURE; + else if (current_state == STATE_INITIALIZED) + target_mask = STATE_LOAD_FAILURE | STATE_HAS_DATA | STATE_INITIALIZED | STATE_PARENT_FAILURE; + else if (current_state == STATE_HAS_DATA) + target_mask = STATE_LOAD_FAILURE | STATE_HAS_DATA | STATE_PARENT_FAILURE; + else if (current_state == STATE_LOAD_FAILURE) + target_mask = STATE_HAS_DATA | STATE_INITIALIZED; + else if (current_state == STATE_PARENT_FAILURE) + target_mask = STATE_INITIALIZED; + + if (new_state & target_mask) + int_vector_iset( map->state , index , new_state); + else + util_abort("%s: illegal state transition for realisation:%d %d -> %d \n" , __func__ , index , current_state , new_state ); + +} + +void state_map_iset( state_map_type * map ,int index , realisation_state_enum state) { + pthread_rwlock_wrlock( &map->rw_lock ); + { + state_map_iset__( map , index , state ); + } + pthread_rwlock_unlock( &map->rw_lock ); +} + +void state_map_update_undefined( state_map_type * map , int index , realisation_state_enum new_state) { + realisation_state_enum current_state = state_map_iget( map , index ); + if (current_state == STATE_UNDEFINED) + state_map_iset( map , index , new_state ); +} + + +void state_map_fwrite( state_map_type * map , const char * filename) { + pthread_rwlock_rdlock( &map->rw_lock ); + { + FILE * stream = util_mkdir_fopen( filename , "w"); + if (stream) { + int_vector_fwrite( map->state , stream ); + fclose( stream ); + } else + util_abort("%s: failed to open:%s for writing \n",__func__ , filename ); + } + pthread_rwlock_unlock( &map->rw_lock ); +} + + + +void state_map_fread( state_map_type * map , const char * filename) { + pthread_rwlock_wrlock( &map->rw_lock ); + { + if (util_file_exists( filename )) { + FILE * stream = util_fopen( filename , "r"); + if (stream) { + int_vector_fread( map->state , stream ); + fclose( stream ); + } else + util_abort("%s: failed to open:%s for reading \n",__func__ , filename ); + } else + int_vector_reset( map->state ); + } + pthread_rwlock_unlock( &map->rw_lock ); +} + + +static void state_map_select_matching__( state_map_type * map , bool_vector_type * select_target , int select_mask , bool select) { + pthread_rwlock_rdlock( &map->rw_lock ); + { + { + const int * map_ptr = int_vector_get_ptr( map->state ); + + for (int i=0; i < int_vector_size( map->state ); i++) { + int state_value = map_ptr[i]; + if (state_value & select_mask) + bool_vector_iset( select_target , i , select); + } + } + pthread_rwlock_unlock( &map->rw_lock ); + } +} + + +void state_map_select_matching( state_map_type * map , bool_vector_type * select_target , int select_mask) { + state_map_select_matching__(map , select_target , select_mask , true ); +} + + + + void state_map_deselect_matching( state_map_type * map , bool_vector_type * select_target , int select_mask) { + state_map_select_matching__(map , select_target , select_mask , false ); +} + + + static void state_map_set_from_mask__( state_map_type * map , const bool_vector_type * mask , realisation_state_enum state, bool invert) { + const bool * mask_ptr = bool_vector_get_ptr(mask); + for (int i=0; i < bool_vector_size( mask); i++) { + if (mask_ptr[i] != invert) + state_map_iset(map , i , state); + } + } + + void state_map_set_from_inverted_mask( state_map_type * state_map , const bool_vector_type * mask , realisation_state_enum state) { + state_map_set_from_mask__(state_map , mask , state , true); + } + + void state_map_set_from_mask( state_map_type * state_map , const bool_vector_type * mask , realisation_state_enum state) { + state_map_set_from_mask__(state_map , mask , state , false); + } + + + int state_map_count_matching( state_map_type * state_map , int mask) { + int count = 0; + pthread_rwlock_rdlock( &state_map->rw_lock ); + { + const int * map_ptr = int_vector_get_ptr( state_map->state ); + for (int i=0; i < int_vector_size( state_map->state ); i++) { + int state_value = map_ptr[i]; + if (state_value & mask) + count++; + } + } + pthread_rwlock_unlock(&state_map->rw_lock); + return count; + } + diff --git a/ThirdParty/Ert/devel/libenkf/tests/CMakeLists.txt b/ThirdParty/Ert/devel/libenkf/tests/CMakeLists.txt index a4ebfbc40e..cda391dec9 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/CMakeLists.txt +++ b/ThirdParty/Ert/devel/libenkf/tests/CMakeLists.txt @@ -7,6 +7,21 @@ target_link_libraries( enkf_site_config enkf test_util ) add_executable( enkf_time_map enkf_time_map.c ) target_link_libraries( enkf_time_map enkf test_util ) + +add_executable( enkf_cases_config enkf_cases_config.c ) +target_link_libraries( enkf_cases_config enkf test_util ) +add_test( enkf_cases_config ${EXECUTABLE_OUTPUT_PATH}/enkf_cases_config ) + +add_executable( enkf_analysis_config enkf_analysis_config.c ) +target_link_libraries( enkf_analysis_config enkf test_util ) +add_test( enkf_analysis ${EXECUTABLE_OUTPUT_PATH}/enkf_analysis_config ) + +add_executable( enkf_state_map enkf_state_map.c ) +target_link_libraries( enkf_state_map enkf test_util ) + +add_executable( enkf_meas_data enkf_meas_data.c ) +target_link_libraries( enkf_meas_data enkf test_util ) + add_executable( enkf_ensemble_GEN_PARAM enkf_ensemble_GEN_PARAM.c ) target_link_libraries( enkf_ensemble_GEN_PARAM enkf test_util ) @@ -31,6 +46,18 @@ add_test( enkf_forward_init_GEN_KW_FALSE ${CMAKE_CURRENT_SOURCE_DIR}/data/config/forward/ert config_GEN_KW_false FALSE) +#----------------------------------------------------------------- + +add_executable( enkf_state_report_step_compatible enkf_state_report_step_compatible.c ) +target_link_libraries( enkf_state_report_step_compatible enkf test_util ) + +add_test( enkf_state_report_step_compatible_TRUE + ${EXECUTABLE_OUTPUT_PATH}/enkf_state_report_step_compatible ${PROJECT_SOURCE_DIR}/test-data/Statoil/config/ecl_sum_compatible_true config_ecl_sum_compatible_true TRUE) + +add_test( enkf_state_report_step_compatible_FALSE + ${EXECUTABLE_OUTPUT_PATH}/enkf_state_report_step_compatible ${PROJECT_SOURCE_DIR}/test-data/Statoil/config/ecl_sum_compatible_false config_ecl_sum_compatible_false FALSE) + + #----------------------------------------------------------------- add_executable( enkf_forward_init_GEN_PARAM enkf_forward_init_GEN_PARAM.c ) @@ -133,10 +160,13 @@ add_test( enkf_time_map1 ${EXECUTABLE_OUTPUT_PATH}/enkf_time_map ) add_test( enkf_time_map2 ${EXECUTABLE_OUTPUT_PATH}/enkf_time_map ${PROJECT_SOURCE_DIR}/test-data/Statoil/ECLIPSE/Gurbat/ECLIPSE.UNRST ) add_test( enkf_ensemble_GEN_PARAM ${EXECUTABLE_OUTPUT_PATH}/enkf_ensemble_GEN_PARAM ${CMAKE_CURRENT_SOURCE_DIR}/data/ensemble/GEN_PARAM ) add_test( enkf_ensemble ${EXECUTABLE_OUTPUT_PATH}/enkf_ensemble ) - +add_test( enkf_state_map ${EXECUTABLE_OUTPUT_PATH}/enkf_state_map ) +add_test( enkf_meas_data ${EXECUTABLE_OUTPUT_PATH}/enkf_meas_data ) set_property( TEST enkf_time_map2 PROPERTY LABELS StatoilData ) set_property( TEST enkf_site_config PROPERTY LABELS StatoilData ) +set_property( TEST enkf_state_report_step_compatible_TRUE PROPERTY LABELS StatoilData ) +set_property( TEST enkf_state_report_step_compatible_FALSE PROPERTY LABELS StatoilData ) set_property( TEST enkf_forward_init_SURFACE_FALSE PROPERTY LABELS StatoilData ) set_property( TEST enkf_forward_init_SURFACE_TRUE PROPERTY LABELS StatoilData ) set_property( TEST enkf_forward_init_FIELD_FALSE PROPERTY LABELS StatoilData ) diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_analysis_config.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_analysis_config.c new file mode 100644 index 0000000000..b2274c3220 --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_analysis_config.c @@ -0,0 +1,83 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'enkf_analysis_config.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#include +#include +#include +#include + +#include +#include +#include + +#include + + +analysis_config_type * create_analysis_config() { + rng_type * rng = rng_alloc( MZRAN , INIT_DEFAULT ); + analysis_config_type * ac = analysis_config_alloc( rng ); + return ac; +} + + +void test_create() { + analysis_config_type * ac = create_analysis_config( ); + test_assert_true( analysis_config_is_instance( ac ) ); + analysis_config_free( ac ); +} + + + +void test_min_realisations( ) { + analysis_config_type * ac = create_analysis_config( ); + test_assert_int_equal( 0 , analysis_config_get_min_realisations( ac ) ); + analysis_config_set_min_realisations( ac , 26 ); + test_assert_int_equal( 26 , analysis_config_get_min_realisations( ac ) ); + analysis_config_free( ac ); +} + + +void test_continue( ) { + analysis_config_type * ac = create_analysis_config( ); + + test_assert_true( analysis_config_have_enough_realisations( ac , 10 )); + test_assert_false( analysis_config_have_enough_realisations( ac , 0 )); + + analysis_config_set_min_realisations( ac , 5 ); + test_assert_true( analysis_config_have_enough_realisations( ac , 10 )); + + analysis_config_set_min_realisations( ac , 15 ); + test_assert_false( analysis_config_have_enough_realisations( ac , 10 )); + + analysis_config_set_min_realisations( ac , 10 ); + test_assert_true( analysis_config_have_enough_realisations( ac , 10 )); + + analysis_config_set_min_realisations( ac , 0 ); + test_assert_true( analysis_config_have_enough_realisations( ac , 10 )); + + analysis_config_free( ac ); +} + + + +int main(int argc , char ** argv) { + test_create(); + test_min_realisations(); + test_continue(); + exit(0); +} + diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_cases_config.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_cases_config.c new file mode 100644 index 0000000000..8063c00f41 --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_cases_config.c @@ -0,0 +1,44 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'enkf_cases_config.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#include +#include +#include +#include + +#include +#include +#include + +#include + + +void test_create_get_set_and_get() { + cases_config_type * cases_config = cases_config_alloc( ); + test_assert_int_equal( 0, cases_config_get_iteration_number( cases_config ) ); + cases_config_set_int( cases_config , "iteration_number" , 12); + test_assert_int_equal( 12, cases_config_get_iteration_number( cases_config ) ); + cases_config_fwrite( cases_config , "TEST_CASES_CONFIG" ); + cases_config_fread( cases_config , "TEST_CASES_CONFIG" ); + cases_config_free( cases_config ); +} + +int main(int argc , char ** argv) { + test_create_get_set_and_get(); + exit(0); +} + diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_FIELD.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_FIELD.c index 33fae2b179..a56742d6e3 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_FIELD.c +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_FIELD.c @@ -37,7 +37,7 @@ void create_runpath(enkf_main_type * enkf_main ) { int start_report = 0; int init_step_parameters = 0; bool_vector_iset( iactive , ens_size - 1 , true ); - enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state); + enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state, true); bool_vector_free(iactive); } @@ -96,7 +96,7 @@ int main(int argc , char ** argv) { test_assert_true( util_is_directory( "simulations/run0" )); { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -108,21 +108,26 @@ int main(int argc , char ** argv) { test_assert_false( enkf_node_has_data( field_node , fs, node_id )); util_unlink_existing( "simulations/run0/petro.grdecl" ); - - test_assert_false( enkf_node_forward_init( field_node , "simulations/run0" , 0 )); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_false( loadOK ); - loadOK = true; - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); - stringlist_free( msg_list ); - test_assert_false( loadOK ); + test_assert_false(enkf_node_forward_init(field_node, "simulations/run0", 0)); + enkf_state_forward_init(state, fs, &error); + test_assert_true(LOAD_FAILURE & error); + + error = 0; + { + enkf_fs_type * fs = enkf_main_get_fs(enkf_main); + state_map_type * state_map = enkf_fs_get_state_map(fs); + state_map_iset(state_map, 0, STATE_INITIALIZED); + } + enkf_state_load_from_forward_model(state, fs, &error, false, msg_list); + stringlist_free(msg_list); + test_assert_true(LOAD_FAILURE & error); } util_copy_file( init_file , "simulations/run0/petro.grdecl"); { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -130,12 +135,14 @@ int main(int argc , char ** argv) { enkf_main_init_run(enkf_main , run_mode); /* This is ugly */ } + test_assert_true( enkf_node_forward_init( field_node , "simulations/run0" , 0)); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_true( loadOK ); - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); + enkf_state_forward_init( state , fs , &error ); + test_assert_int_equal( error, 0 ); + enkf_state_load_from_forward_model( state , fs , &error , false , msg_list ); + stringlist_free( msg_list ); - test_assert_true( loadOK ); + test_assert_int_equal(error, 0); { double value; diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_KW.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_KW.c index 4de0c97afc..04ccfef1f4 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_KW.c +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_KW.c @@ -37,7 +37,7 @@ void create_runpath(enkf_main_type * enkf_main ) { int start_report = 0; int init_step_parameters = 0; bool_vector_iset( iactive , ens_size - 1 , true ); - enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state); + enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state, true); bool_vector_free(iactive); } @@ -94,7 +94,7 @@ int main(int argc , char ** argv) { test_assert_true( util_is_directory( "simulations/run0" )); { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -106,14 +106,20 @@ int main(int argc , char ** argv) { test_assert_false( enkf_node_has_data( gen_kw_node , fs, node_id )); util_unlink_existing( "simulations/run0/MULTFLT_INIT" ); + test_assert_false( enkf_node_forward_init( gen_kw_node , "simulations/run0" , 0 )); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_false( loadOK ); + enkf_state_forward_init( state , fs , &error ); + test_assert_true(LOAD_FAILURE & error); - loadOK = true; - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); + error = 0; + { + enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); + state_map_type * state_map = enkf_fs_get_state_map(fs); + state_map_iset(state_map , 0 , STATE_INITIALIZED); + } + enkf_state_load_from_forward_model( state , fs , &error , false , msg_list ); stringlist_free( msg_list ); - test_assert_false( loadOK ); + test_assert_true(LOAD_FAILURE & error); } @@ -125,7 +131,7 @@ int main(int argc , char ** argv) { } { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -133,12 +139,14 @@ int main(int argc , char ** argv) { enkf_main_init_run(enkf_main , run_mode); /* This is ugly */ } + test_assert_true( enkf_node_forward_init( gen_kw_node , "simulations/run0" , 0 )); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_true( loadOK ); - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); + enkf_state_forward_init( state , fs , &error ); + test_assert_int_equal(0, error); + enkf_state_load_from_forward_model( state , fs , &error , false , msg_list ); + stringlist_free( msg_list ); - test_assert_true( loadOK ); + test_assert_int_equal(0, error); { double value; diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_PARAM.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_PARAM.c index a6a0424759..5ed9c5bcaa 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_PARAM.c +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_GEN_PARAM.c @@ -37,7 +37,7 @@ void create_runpath(enkf_main_type * enkf_main ) { int start_report = 0; int init_step_parameters = 0; bool_vector_iset( iactive , ens_size - 1 , true ); - enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state); + enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state, true); bool_vector_free(iactive); } @@ -111,7 +111,7 @@ int main(int argc , char ** argv) { } { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -120,11 +120,18 @@ int main(int argc , char ** argv) { } test_assert_true( enkf_node_forward_init( gen_param_node , "simulations/run0" , 0 )); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_true( loadOK ); - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); + + enkf_state_forward_init( state , fs , &error ); + test_assert_int_equal(0, error); + { + enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); + state_map_type * state_map = enkf_fs_get_state_map(fs); + state_map_iset(state_map , 0 , STATE_INITIALIZED); + } + enkf_state_load_from_forward_model( state , fs , &error , false , msg_list ); + stringlist_free( msg_list ); - test_assert_true( loadOK ); + test_assert_int_equal(0, error); { double value; diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_SURFACE.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_SURFACE.c index 0122e6f0ad..35ed10f03d 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_SURFACE.c +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_forward_init_SURFACE.c @@ -37,7 +37,7 @@ void create_runpath(enkf_main_type * enkf_main ) { int start_report = 0; int init_step_parameters = 0; bool_vector_iset( iactive , ens_size - 1 , true ); - enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state); + enkf_main_run_exp(enkf_main , iactive , false , init_step_parameters , start_report , init_state, true); bool_vector_free(iactive); } @@ -98,7 +98,7 @@ int main(int argc , char ** argv) { test_assert_true( util_is_directory( "simulations/run0" )); { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -112,19 +112,25 @@ int main(int argc , char ** argv) { util_unlink_existing( "simulations/run0/Surface.irap" ); test_assert_false( enkf_node_forward_init( surface_node , "simulations/run0" , 0 )); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_false( loadOK ); + enkf_state_forward_init( state , fs , &error ); + test_assert_true(LOAD_FAILURE & error); + + error = 0; + { + enkf_fs_type * fs = enkf_main_get_fs(enkf_main); + state_map_type * state_map = enkf_fs_get_state_map(fs); + state_map_iset(state_map, 0, STATE_INITIALIZED); + } + enkf_state_load_from_forward_model(state, fs, &error, false, msg_list); - loadOK = true; - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); stringlist_free( msg_list ); - test_assert_false( loadOK ); + test_assert_true(LOAD_FAILURE & error); } util_copy_file( init_file , "simulations/run0/Surface.irap"); { - bool loadOK = true; + int error = 0; stringlist_type * msg_list = stringlist_alloc_new(); { @@ -133,11 +139,11 @@ int main(int argc , char ** argv) { } test_assert_true( enkf_node_forward_init( surface_node , "simulations/run0" , 0 )); - enkf_state_forward_init( state , fs , &loadOK ); - test_assert_true( loadOK ); - enkf_state_load_from_forward_model( state , fs , &loadOK , false , msg_list ); + enkf_state_forward_init( state , fs , &error ); + test_assert_int_equal(0, error); + enkf_state_load_from_forward_model( state , fs , &error , false , msg_list ); stringlist_free( msg_list ); - test_assert_true( loadOK ); + test_assert_int_equal(0, error); { double value; diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_iter_config.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_iter_config.c index 8232c59bff..758d9da497 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/enkf_iter_config.c +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_iter_config.c @@ -27,6 +27,7 @@ #include #include +#include #include #include @@ -61,8 +62,10 @@ int main(int argc , char ** argv) { { analysis_iter_config_type * iter_config = analysis_iter_config_alloc(); - test_assert_string_equal( analysis_iter_config_iget_case( iter_config , 5) , NULL ); - test_assert_string_equal( analysis_iter_config_iget_runpath_fmt( iter_config , 5) , NULL ); + char itercase[50]; + sprintf(itercase,DEFAULT_ANALYSIS_ITER_CASE,5); + test_assert_string_equal( analysis_iter_config_iget_case( iter_config , 5) , itercase ); + test_assert_string_equal( analysis_iter_config_iget_runpath_fmt( iter_config , 5) , DEFAULT_ANALYSIS_ITER_RUNPATH ); analysis_iter_config_init( iter_config , config ); @@ -71,7 +74,7 @@ int main(int argc , char ** argv) { test_assert_string_equal( analysis_iter_config_iget_runpath_fmt( iter_config , 5) , "run/iter5/real%d" ); analysis_iter_config_free( iter_config ); - } + } remove( config_file ); free( config_file ); config_free( config ); diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_meas_data.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_meas_data.c new file mode 100644 index 0000000000..3954b8acb3 --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_meas_data.c @@ -0,0 +1,52 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'enkf_meas_data.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#include +#include +#include +#include + +#include +#include + +#include + + + +void create_test() { + int_vector_type * ens_active_list = int_vector_alloc(0 , false); + int_vector_append( ens_active_list , 10 ); + int_vector_append( ens_active_list , 20 ); + int_vector_append( ens_active_list , 30 ); + + { + meas_data_type * meas_data = meas_data_alloc( ens_active_list ); + test_assert_int_equal( 3 , meas_data_get_ens_size( meas_data )); + + meas_data_free( meas_data ); + } + + int_vector_free( ens_active_list ); +} + + + +int main(int argc , char ** argv) { + create_test(); + exit(0); +} + diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_model_config.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_model_config.c index 519b51917d..cbf8eaa035 100644 --- a/ThirdParty/Ert/devel/libenkf/tests/enkf_model_config.c +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_model_config.c @@ -20,12 +20,39 @@ #include #include +#include + #include -int main(int argc , char ** argv) { - model_config_type * model_config = model_config_alloc_empty(); +void test_create() { + model_config_type * model_config = model_config_alloc(); + test_assert_true( model_config_is_instance( model_config)); model_config_free( model_config ); +} + + +void test_runpath() { + model_config_type * model_config = model_config_alloc(); + model_config_add_runpath(model_config , "KEY" , "RunPath%d"); + model_config_add_runpath(model_config , "KEY2" , "2-RunPath%d"); + test_assert_true( model_config_select_runpath(model_config , "KEY")); + test_assert_false( model_config_select_runpath(model_config , "KEYX")); + test_assert_string_equal("RunPath%d" , model_config_get_runpath_as_char(model_config)); + + model_config_set_runpath( model_config , "PATH%d"); + test_assert_string_equal("PATH%d" , model_config_get_runpath_as_char(model_config)); + test_assert_true( model_config_select_runpath(model_config , "KEY2")); + test_assert_string_equal("2-RunPath%d" , model_config_get_runpath_as_char(model_config)); + test_assert_true( model_config_select_runpath(model_config , "KEY")); + test_assert_string_equal("PATH%d" , model_config_get_runpath_as_char(model_config)); + + model_config_free( model_config ); +} + + +int main(int argc , char ** argv) { + test_create(); exit(0); } diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_state_map.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_state_map.c new file mode 100644 index 0000000000..fe035a2081 --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_state_map.c @@ -0,0 +1,274 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'enkf_state_map.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + + +void create_test() { + state_map_type * state_map = state_map_alloc(); + test_assert_true( state_map_is_instance( state_map )); + test_assert_int_equal( 0 , state_map_get_size( state_map )); + state_map_free( state_map ); +} + +void get_test( ) { + state_map_type * state_map = state_map_alloc(); + test_assert_int_equal( STATE_UNDEFINED , state_map_iget( state_map , 0 )); + test_assert_int_equal( STATE_UNDEFINED , state_map_iget( state_map , 100 )); + state_map_free( state_map ); +} + +void set_test( ) { + state_map_type * state_map = state_map_alloc(); + state_map_iset( state_map , 0 , STATE_INITIALIZED ); + test_assert_int_equal( STATE_INITIALIZED , state_map_iget( state_map , 0 )); + + state_map_iset( state_map , 100 , STATE_INITIALIZED ); + test_assert_int_equal( STATE_INITIALIZED , state_map_iget( state_map , 100 )); + + test_assert_int_equal( STATE_UNDEFINED , state_map_iget( state_map , 50 )); + test_assert_int_equal( 101 , state_map_get_size( state_map )); + state_map_free( state_map ); +} + + +void load_empty_test() { + state_map_type * state_map = state_map_fread_alloc( "File/does/not/exists" ); + test_assert_true( state_map_is_instance( state_map )); + test_assert_int_equal( 0 , state_map_get_size( state_map )); + state_map_free( state_map ); +} + + +void test_equal() { + state_map_type * state_map1 = state_map_alloc(); + state_map_type * state_map2 = state_map_alloc(); + + test_assert_true( state_map_equal( state_map1 , state_map2 )); + for (int i =0; i < 25; i++) { + state_map_iset( state_map1 , i , STATE_INITIALIZED ); + state_map_iset( state_map2 , i , STATE_INITIALIZED ); + } + test_assert_true( state_map_equal( state_map1 , state_map2 )); + + state_map_iset( state_map2 , 15 , STATE_HAS_DATA ); + test_assert_false( state_map_equal( state_map1 , state_map2 )); + state_map_iset( state_map2 , 15 , STATE_LOAD_FAILURE ); + state_map_iset( state_map2 , 15 , STATE_INITIALIZED ); + test_assert_true( state_map_equal( state_map1 , state_map2 )); + + state_map_iset( state_map2 , 150 , STATE_INITIALIZED ); + test_assert_false( state_map_equal( state_map1 , state_map2 )); +} + + +void test_copy() { + state_map_type * state_map = state_map_alloc(); + state_map_iset( state_map , 0 , STATE_INITIALIZED ); + state_map_iset( state_map , 100 , STATE_INITIALIZED ); + { + state_map_type * copy = state_map_alloc_copy( state_map ); + test_assert_true( state_map_equal( copy , state_map )); + + state_map_iset( state_map , 10 , STATE_INITIALIZED ); + test_assert_false( state_map_equal( copy , state_map )); + + state_map_free( copy ); + } + state_map_free( state_map ); +} + + +void test_io( ) { + test_work_area_type * work_area = test_work_area_alloc( "enkf-state-map" , false ); + { + state_map_type * state_map = state_map_alloc(); + state_map_type * copy1 , *copy2; + state_map_iset( state_map , 0 , STATE_INITIALIZED ); + state_map_iset( state_map , 100 , STATE_INITIALIZED ); + state_map_fwrite( state_map , "map"); + + copy1 = state_map_fread_alloc( "map" ); + test_assert_true( state_map_equal( state_map , copy1 )); + + copy2 = state_map_alloc(); + state_map_fread( copy2 , "map" ); + test_assert_true( state_map_equal( state_map , copy2 )); + + state_map_iset( copy2 , 67 , STATE_INITIALIZED ); + test_assert_false(state_map_equal( state_map , copy2 )); + + state_map_fread( copy2 , "map"); + test_assert_true( state_map_equal( state_map , copy2 )); + + state_map_fread( copy2 , "DoesNotExis"); + test_assert_int_equal( 0 , state_map_get_size( copy2 )); + } + test_work_area_free( work_area ); +} + + + +void test_update_undefined( ) { + state_map_type * map = state_map_alloc( ); + + state_map_iset( map , 10 , STATE_INITIALIZED ); + test_assert_int_equal( STATE_UNDEFINED , state_map_iget( map , 5 ) ); + test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) ); + + state_map_update_undefined( map , 5 , STATE_INITIALIZED ); + test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 5 ) ); + + state_map_update_undefined( map , 10 , STATE_INITIALIZED ); + test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map , 10 ) ); + + state_map_free( map ); +} + + +void test_select_matching( ) { + state_map_type * map = state_map_alloc( ); + bool_vector_type * mask1 = bool_vector_alloc(0 , false); + bool_vector_type * mask2 = bool_vector_alloc(1000 , true); + + state_map_iset( map , 10 , STATE_INITIALIZED ); + state_map_iset( map , 10 , STATE_HAS_DATA ); + state_map_iset( map , 20 , STATE_INITIALIZED ); + state_map_select_matching( map , mask1 , STATE_HAS_DATA | STATE_INITIALIZED ); + state_map_select_matching( map , mask2 , STATE_HAS_DATA | STATE_INITIALIZED ); + + test_assert_int_equal( state_map_get_size( map ) , bool_vector_size( mask1 )); + + for (int i=0; i < bool_vector_size( mask1 ); i++) { + if (i==10) + test_assert_true( bool_vector_iget( mask1 , i )); + else if (i== 20) + test_assert_true( bool_vector_iget( mask1 , i )); + else { + test_assert_false( bool_vector_iget( mask1 , i )); + test_assert_true( bool_vector_iget( mask2 , i )); + } + } + + bool_vector_free( mask1 ); + bool_vector_free( mask2 ); + state_map_free( map ); +} + + +void test_deselect_matching( ) { + state_map_type * map = state_map_alloc( ); + bool_vector_type * mask1 = bool_vector_alloc(0 , false); + bool_vector_type * mask2 = bool_vector_alloc(1000 , true); + + state_map_iset( map , 10 , STATE_INITIALIZED ); + state_map_iset( map , 10 , STATE_HAS_DATA ); + state_map_iset( map , 20 , STATE_INITIALIZED ); + state_map_deselect_matching( map , mask1 , STATE_HAS_DATA | STATE_INITIALIZED ); + state_map_deselect_matching( map , mask2 , STATE_HAS_DATA | STATE_INITIALIZED ); + + test_assert_int_equal( state_map_get_size( map ) , bool_vector_size( mask1 )); + + for (int i=0; i < bool_vector_size( mask1 ); i++) { + if (i==10) + test_assert_false( bool_vector_iget( mask1 , i )); + else if (i== 20) + test_assert_false( bool_vector_iget( mask2 , i )); + else { + test_assert_false( bool_vector_iget( mask1 , i )); + test_assert_true( bool_vector_iget( mask2 , i )); + } + } + + bool_vector_free( mask1 ); + bool_vector_free( mask2 ); + state_map_free( map ); +} + + +void test_set_from_mask() { + int i; + state_map_type * map1 = state_map_alloc(); + state_map_type * map2 = state_map_alloc(); + bool_vector_type * mask = bool_vector_alloc(0, false); + bool_vector_iset(mask , 10 , true); + bool_vector_iset(mask , 20 , true); + + state_map_set_from_mask(map1 , mask , STATE_INITIALIZED); + state_map_set_from_inverted_mask(map2 , mask , STATE_INITIALIZED); + test_assert_int_equal(21 , state_map_get_size(map1)); + test_assert_int_equal(21 , state_map_get_size(map2)); + for (i = 0; i < state_map_get_size(map1); i++) { + if (i == 10 || i== 20) { + test_assert_int_equal( STATE_INITIALIZED , state_map_iget( map1 , i) ); + test_assert_int_equal( STATE_UNDEFINED , state_map_iget(map2 , i)); + } + else { + test_assert_int_equal(STATE_UNDEFINED , state_map_iget(map1 , i )); + test_assert_int_equal( STATE_INITIALIZED , state_map_iget(map2 , i)); + } + + + } +} + + +void test_count_matching() { + state_map_type * map1 = state_map_alloc(); + state_map_iset(map1 , 10 , STATE_INITIALIZED ); + + state_map_iset(map1 , 15 , STATE_INITIALIZED ); + state_map_iset(map1 , 15 , STATE_HAS_DATA ); + + state_map_iset(map1 , 16 , STATE_INITIALIZED ); + state_map_iset(map1 , 16 , STATE_HAS_DATA ); + state_map_iset(map1 , 16 , STATE_LOAD_FAILURE ); + + test_assert_int_equal( 1 , state_map_count_matching( map1 , STATE_HAS_DATA)); + test_assert_int_equal( 2 , state_map_count_matching( map1 , STATE_HAS_DATA | STATE_LOAD_FAILURE)); + test_assert_int_equal( 3 , state_map_count_matching( map1 , STATE_HAS_DATA | STATE_LOAD_FAILURE | STATE_INITIALIZED)); + + state_map_free( map1 ); +} + +int main(int argc , char ** argv) { + create_test(); + get_test(); + set_test(); + load_empty_test(); + test_equal(); + test_copy(); + test_io(); + test_update_undefined( ); + test_select_matching(); + test_count_matching(); + exit(0); +} + diff --git a/ThirdParty/Ert/devel/libenkf/tests/enkf_state_report_step_compatible.c b/ThirdParty/Ert/devel/libenkf/tests/enkf_state_report_step_compatible.c new file mode 100644 index 0000000000..50de52ec6e --- /dev/null +++ b/ThirdParty/Ert/devel/libenkf/tests/enkf_state_report_step_compatible.c @@ -0,0 +1,85 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'enkf_state_report_step_compatible.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#include +#include +#include +#include + +#include +#include +#include + +#include + + +bool check_ecl_sum_compatible(const enkf_main_type * enkf_main) +{ + stringlist_type * msg_list = stringlist_alloc_new(); + enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 ); + enkf_fs_type * fs = enkf_main_get_fs( enkf_main ); + + state_map_type * state_map = enkf_fs_get_state_map(fs); + state_map_iset(state_map, 0, STATE_INITIALIZED); + + int error = 0; + + enkf_state_load_from_forward_model( state , fs , &error , false , msg_list ); + + stringlist_free( msg_list ); + return (REPORT_STEP_INCOMPATIBLE & error) ? false : true; +} + + + +int main(int argc , char ** argv) { + enkf_main_install_SIGNALS(); + const char * root_path = argv[1]; + const char * config_file = argv[2]; + const char * compatible_str = argv[3]; + bool check_compatible; + + test_assert_true( util_sscanf_bool( compatible_str , &check_compatible)); + + test_work_area_type * work_area = test_work_area_alloc(config_file , false); + test_work_area_copy_directory_content( work_area , root_path ); + + bool strict = true; + enkf_main_type * enkf_main = enkf_main_bootstrap( NULL , config_file , strict , true ); + + { + run_mode_type run_mode = ENSEMBLE_EXPERIMENT; + enkf_main_init_run(enkf_main , run_mode); /* This is ugly */ + + enkf_state_type * state = enkf_main_iget_state( enkf_main , 0 ); + bool active = true; + int max_internal_sumbit = 1; + int init_step_parameter = 1; + state_enum init_state_parameter = FORECAST; + state_enum init_state_dynamic = FORECAST; + int load_start = 1; + int step1 = 1; + int step2 = 1; + + enkf_state_init_run(state, run_mode, active, max_internal_sumbit, init_step_parameter, init_state_parameter, init_state_dynamic, load_start, step1, step2); + } + + test_assert_bool_equal(check_compatible, check_ecl_sum_compatible(enkf_main)); + + enkf_main_free( enkf_main ); + test_work_area_free(work_area); +} diff --git a/ThirdParty/Ert/devel/libert_util/include/ert/util/thread_pool.h b/ThirdParty/Ert/devel/libert_util/include/ert/util/thread_pool.h index 0f4fbe4e0a..8a2ca9d206 100644 --- a/ThirdParty/Ert/devel/libert_util/include/ert/util/thread_pool.h +++ b/ThirdParty/Ert/devel/libert_util/include/ert/util/thread_pool.h @@ -20,7 +20,7 @@ #ifdef WITH_PTHREAD #define WITH_THREAD_POOL -#include "thread_pool_posix.h" +#include #endif #endif diff --git a/ThirdParty/Ert/devel/libert_util/include/ert/util/type_vector_functions.h b/ThirdParty/Ert/devel/libert_util/include/ert/util/type_vector_functions.h new file mode 100644 index 0000000000..8e2cfcc9d2 --- /dev/null +++ b/ThirdParty/Ert/devel/libert_util/include/ert/util/type_vector_functions.h @@ -0,0 +1,34 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'type_vector_functions.h' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ +#ifndef __TYPE_VECTOR_FUNCTIONS_H__ +#define __TYPE_VECTOR_FUNCTIONS_H__ + +#ifdef __cplusplus +extern "C" { +#endif +#include +#include + + int_vector_type * bool_vector_alloc_active_list( const bool_vector_type * mask ); + bool_vector_type * int_vector_alloc_mask( const int_vector_type * active_list ); + int_vector_type * bool_vector_alloc_active_index_list(const bool_vector_type * mask , int default_value); + +#ifdef __cplusplus +} +#endif +#endif diff --git a/ThirdParty/Ert/devel/libert_util/include/ert/util/util.h b/ThirdParty/Ert/devel/libert_util/include/ert/util/util.h index b664a78ea5..810f1ff419 100644 --- a/ThirdParty/Ert/devel/libert_util/include/ert/util/util.h +++ b/ThirdParty/Ert/devel/libert_util/include/ert/util/util.h @@ -22,9 +22,14 @@ #include #include #include -#include #include #include +#include + +#ifdef HAVE_GETPWUID +#include +#endif + #ifdef HAVE_GETUID #include @@ -278,6 +283,7 @@ typedef enum {left_pad = 0, void util_fread_dev_urandom(int , char * ); bool util_string_isspace(const char * s); + char * util_alloc_dump_filename(); void util_exit(const char * fmt , ...); void util_abort(const char * fmt , ...); void util_abort_signal(int ); diff --git a/ThirdParty/Ert/devel/libert_util/src/CMakeLists.txt b/ThirdParty/Ert/devel/libert_util/src/CMakeLists.txt index ec8e8d4e20..9004407e23 100644 --- a/ThirdParty/Ert/devel/libert_util/src/CMakeLists.txt +++ b/ThirdParty/Ert/devel/libert_util/src/CMakeLists.txt @@ -1,6 +1,6 @@ -set(source_files rng.c lookup_table.c statistics.c mzran.c set.c hash_node.c hash_sll.c hash.c node_data.c node_ctype.c util.c thread_pool.c msg.c arg_pack.c path_fmt.c menu.c subst_list.c subst_func.c vector.c parser.c stringlist.c matrix.c buffer.c log.c template.c timer.c time_interval.c string_util.c) +set(source_files rng.c lookup_table.c statistics.c mzran.c set.c hash_node.c hash_sll.c hash.c node_data.c node_ctype.c util.c thread_pool.c msg.c arg_pack.c path_fmt.c menu.c subst_list.c subst_func.c vector.c parser.c stringlist.c matrix.c buffer.c log.c template.c timer.c time_interval.c string_util.c type_vector_functions.c) -set(header_files ssize_t.h type_macros.h rng.h lookup_table.h statistics.h mzran.h set.h hash.h hash_node.h hash_sll.h node_data.h node_ctype.h util.h thread_pool.h msg.h arg_pack.h path_fmt.h stringlist.h menu.h subst_list.h subst_func.h vector.h parser.h matrix.h buffer.h log.h template.h timer.h time_interval.h string_util.h) +set(header_files ssize_t.h type_macros.h rng.h lookup_table.h statistics.h mzran.h set.h hash.h hash_node.h hash_sll.h node_data.h node_ctype.h util.h thread_pool.h msg.h arg_pack.h path_fmt.h stringlist.h menu.h subst_list.h subst_func.h vector.h parser.h matrix.h buffer.h log.h template.h timer.h time_interval.h string_util.h type_vector_functions.h) set( test_source test_util.c test_work_area.c ) diff --git a/ThirdParty/Ert/devel/libert_util/src/string_util.c b/ThirdParty/Ert/devel/libert_util/src/string_util.c index 7a207e778c..ed0b2fd60a 100644 --- a/ThirdParty/Ert/devel/libert_util/src/string_util.c +++ b/ThirdParty/Ert/devel/libert_util/src/string_util.c @@ -23,7 +23,7 @@ #include #include #include - +#include /*****************************************************************/ @@ -127,21 +127,13 @@ static int_vector_type * string_util_sscanf_alloc_active_list(const char * range /*****************************************************************/ -static bool_vector_type * alloc_mask( const int_vector_type * active_list ) { - bool_vector_type * mask = bool_vector_alloc( 0 , false ); - int i; - for (i=0; i < int_vector_size( active_list ); i++) - bool_vector_iset( mask , int_vector_iget( active_list , i) , true ); - - return mask; -} bool string_util_update_active_list( const char * range_string , int_vector_type * active_list ) { int_vector_sort( active_list ); { - bool_vector_type * mask = alloc_mask( active_list ); + bool_vector_type * mask = int_vector_alloc_mask( active_list ); bool valid = false; if (string_util_update_active_mask( range_string , mask )) { diff --git a/ThirdParty/Ert/devel/libert_util/src/test_work_area.c b/ThirdParty/Ert/devel/libert_util/src/test_work_area.c index c1b1f60738..fbe9f62fd1 100644 --- a/ThirdParty/Ert/devel/libert_util/src/test_work_area.c +++ b/ThirdParty/Ert/devel/libert_util/src/test_work_area.c @@ -106,7 +106,7 @@ test_work_area_type * test_work_area_alloc(const char * test_name, bool retain) if (test_name) { uid_t uid = getuid(); struct passwd * pw = getpwuid( uid ); - rng_type * rng = rng_alloc(MZRAN , INIT_CLOCK ); + rng_type * rng = rng_alloc(MZRAN , INIT_DEV_URANDOM ); char * path = util_alloc_sprintf( PATH_FMT , pw->pw_name , test_name , rng_get_int( rng , 100000000 )); test_work_area_type * work_area = test_work_area_alloc__( path , retain ); free( path ); diff --git a/ThirdParty/Ert/devel/libert_util/src/type_vector_functions.c b/ThirdParty/Ert/devel/libert_util/src/type_vector_functions.c new file mode 100644 index 0000000000..b3f19370f3 --- /dev/null +++ b/ThirdParty/Ert/devel/libert_util/src/type_vector_functions.c @@ -0,0 +1,61 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'ert_util_vector_function.c' is part of ERT - Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ + + +#include +#include + + + +int_vector_type * bool_vector_alloc_active_list( const bool_vector_type * mask ) { + int_vector_type * active_list = int_vector_alloc(0,0); + int i; + + for (i =0; i < bool_vector_size( mask ); i++) + if (bool_vector_iget( mask , i )) + int_vector_append( active_list , i ); + + return active_list; +} + + +int_vector_type * bool_vector_alloc_active_index_list(const bool_vector_type * mask , int default_value) { + int_vector_type * index_list = int_vector_alloc(bool_vector_size( mask) , default_value); + int active_index = 0; + int i; + for (i=0; i < bool_vector_size(mask); i++) { + if (bool_vector_iget( mask , i)) { + int_vector_iset(index_list , i , active_index); + active_index++; + } + } + return index_list; +} + + +bool_vector_type * int_vector_alloc_mask( const int_vector_type * active_list ) { + bool_vector_type * mask = bool_vector_alloc( 0 , false ); + int i; + for (i=0; i < int_vector_size( active_list ); i++) + bool_vector_iset( mask , int_vector_iget( active_list , i) , true ); + + return mask; +} + + + diff --git a/ThirdParty/Ert/devel/libert_util/src/util.c b/ThirdParty/Ert/devel/libert_util/src/util.c index d28337a9bd..c73653748e 100644 --- a/ThirdParty/Ert/devel/libert_util/src/util.c +++ b/ThirdParty/Ert/devel/libert_util/src/util.c @@ -38,10 +38,12 @@ #ifdef HAVE_FORK #ifdef WITH_PTHREAD #ifdef HAVE_EXECINFO +#ifdef HAVE_GETPWUID #define HAVE_UTIL_ABORT #endif #endif #endif +#endif #ifdef HAVE_UTIL_ABORT #define __USE_GNU // Must be defined to get access to the dladdr() function; Man page says the symbol should be: _GNU_SOURCE but that does not seem to work? diff --git a/ThirdParty/Ert/devel/libert_util/src/util_abort_gnu.c b/ThirdParty/Ert/devel/libert_util/src/util_abort_gnu.c index 8aeb8f5b08..180ffc0a19 100644 --- a/ThirdParty/Ert/devel/libert_util/src/util_abort_gnu.c +++ b/ThirdParty/Ert/devel/libert_util/src/util_abort_gnu.c @@ -1,18 +1,16 @@ /* - This file implements the fully fledged util abort() function which + This file implements the fully fledged util�abort() function which assumes that the current build has the following features: fork() : To support calling external program addr2line(). - pthread : To serialize the use of util abort() - not very important. - execinfo.h : The backtrace functions backtrace() and backtrace symbols(). + pthread : To serialize the use of util�abort() - not very important. + execinfo.h : The backtrace functions backtrace() and backtrace�symbols(). _GNU_SOURCE : To get the dladdr() function. If not all these features are availbale the simpler version in - util abort_simple.c is built instead. + util�abort_simple.c is built instead. */ - - /** This function uses the external program addr2line to convert the hexadecimal adress given by the libc function backtrace() into a @@ -175,15 +173,36 @@ static void util_fprintf_backtrace(FILE * stream) { fprintf(stream , "--------------------------------------------------------------------------------\n"); } +char * util_alloc_dump_filename() { + time_t timestamp = time(NULL); + struct tm *converted = localtime(×tamp); + char day[32]; + size_t last = strftime(day, 32, "%Y%m%d-%H%M%S", converted); + day[last] = '\0'; + + struct passwd *pwd = getpwuid(getuid()); + char * filename = util_alloc_sprintf("/tmp/ert_abort_dump.%s.%s.log", pwd->pw_name, day); + return filename; +} + void util_abort(const char * fmt , ...) { pthread_mutex_lock( &__abort_mutex ); /* Abort before unlock() */ { + char * filename = util_alloc_dump_filename(); + + bool dump_to_file = true; + FILE * abort_dump = fopen(filename, "w"); + if (abort_dump == NULL) { + abort_dump = stderr; + dump_to_file = false; + } + va_list ap; va_start(ap , fmt); - fprintf(stderr , "\n\n"); - fprintf(stderr , "\n\n"); - vfprintf(stderr , fmt , ap); + fprintf(abort_dump , "\n\n"); + vfprintf(abort_dump , fmt , ap); + fprintf(abort_dump , "\n\n"); va_end(ap); /* @@ -191,37 +210,29 @@ void util_abort(const char * fmt , ...) { addr2line; the call is based on util_fork_exec() which is currently only available on POSIX. */ - const bool include_backtrace = true; if (include_backtrace) { if (__abort_program_message != NULL) { - fprintf(stderr,"--------------------------------------------------------------------------------\n"); - fprintf(stderr,"%s",__abort_program_message); - fprintf(stderr, "Current executable ..: %s\n" , program_invocation_name); - fprintf(stderr,"--------------------------------------------------------------------------------\n"); + fprintf(abort_dump,"--------------------------------------------------------------------------------\n"); + fprintf(abort_dump,"%s",__abort_program_message); + fprintf(abort_dump, "Current executable ..: %s\n" , program_invocation_name); + fprintf(abort_dump,"--------------------------------------------------------------------------------\n"); } - fprintf(stderr,"\n"); - fprintf(stderr,"****************************************************************************\n"); - fprintf(stderr,"** **\n"); - fprintf(stderr,"** A fatal error occured, and we have to abort. **\n"); - fprintf(stderr,"** **\n"); - fprintf(stderr,"** We now *try* to provide a backtrace, which would be very useful **\n"); - fprintf(stderr,"** when debugging. The process of making a (human readable) backtrace **\n"); - fprintf(stderr,"** is quite complex, among other things it involves several calls to the **\n"); - fprintf(stderr,"** external program addr2line. We have arrived here because the program **\n"); - fprintf(stderr,"** state is already quite broken, so the backtrace might be (seriously) **\n"); - fprintf(stderr,"** broken as well. **\n"); - fprintf(stderr,"** **\n"); - fprintf(stderr,"****************************************************************************\n"); - - util_fprintf_backtrace( stderr ); + fprintf(abort_dump,"\n"); + util_fprintf_backtrace( abort_dump ); } - } - pthread_mutex_unlock( &__abort_mutex ); - signal(SIGABRT , SIG_DFL); - fprintf(stderr , "Aborting ... \n"); + if (dump_to_file) { + util_fclose(abort_dump); + fprintf(stderr, "\n\nA fatal error occured, see file %s for details \n", filename); + } + + free(filename); + } + + pthread_mutex_unlock(&__abort_mutex); + signal(SIGABRT, SIG_DFL); abort(); } diff --git a/ThirdParty/Ert/devel/libert_util/tests/CMakeLists.txt b/ThirdParty/Ert/devel/libert_util/tests/CMakeLists.txt index 5457bf2469..8c715300f2 100644 --- a/ThirdParty/Ert/devel/libert_util/tests/CMakeLists.txt +++ b/ThirdParty/Ert/devel/libert_util/tests/CMakeLists.txt @@ -95,6 +95,10 @@ add_executable( ert_util_file_readable ert_util_file_readable.c ) target_link_libraries( ert_util_file_readable ert_util test_util ) add_test( ert_util_file_readable ${EXECUTABLE_OUTPUT_PATH}/ert_util_file_readable ${FILE_READABLE_SERVERS}) +add_executable( ert_util_type_vector_functions ert_util_type_vector_functions.c ) +target_link_libraries( ert_util_type_vector_functions ert_util test_util ) +add_test( ert_util_type_vector_functions ${EXECUTABLE_OUTPUT_PATH}/ert_util_type_vector_functions) + add_executable( ert_util_addr2line ert_util_addr2line.c ) target_link_libraries( ert_util_addr2line ert_util test_util ) add_test( ert_util_addr2line ${EXECUTABLE_OUTPUT_PATH}/ert_util_addr2line) @@ -118,3 +122,7 @@ add_executable( ert_util_arg_pack ert_util_arg_pack.c) set_target_properties( ert_util_arg_pack PROPERTIES COMPILE_FLAGS "-Werror") target_link_libraries( ert_util_arg_pack ert_util test_util ) add_test( ert_util_arg_pack ${EXECUTABLE_OUTPUT_PATH}/ert_util_arg_pack) + +add_executable( ert_util_abort_gnu_tests ert_util_abort_gnu_tests.c) +target_link_libraries( ert_util_abort_gnu_tests ert_util test_util) +add_test( ert_util_abort_gnu_tests ${EXECUTABLE_OUTPUT_PATH}/ert_util_abort_gnu_tests) diff --git a/ThirdParty/Ert/devel/libert_util/tests/ert_util_abort_gnu_tests.c b/ThirdParty/Ert/devel/libert_util/tests/ert_util_abort_gnu_tests.c new file mode 100644 index 0000000000..7ea7eab064 --- /dev/null +++ b/ThirdParty/Ert/devel/libert_util/tests/ert_util_abort_gnu_tests.c @@ -0,0 +1,44 @@ +/* + * File: ert_util_abort_gnu_tests.c + * Author: kflik + * + * Created on August 16, 2013, 9:41 AM + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +/* + * + */ +int main(int argc, char** argv) { + + char * filename = util_alloc_dump_filename(); + + if (util_file_exists(filename)) { + remove(filename); + } + + test_assert_false(util_file_exists(filename)); + + pid_t child_pid = fork(); + + if (child_pid == 0) { + util_abort("I was terminated with the util_abort function"); + } else { + waitpid(child_pid, NULL, 0); + test_assert_true(util_file_exists(filename)); + free(filename); + } + + return (EXIT_SUCCESS); +} + diff --git a/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_functions.c b/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_functions.c new file mode 100644 index 0000000000..dc67cfa2b3 --- /dev/null +++ b/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_functions.c @@ -0,0 +1,106 @@ +/* + Copyright (C) 2013 Statoil ASA, Norway. + + The file 'ert_util_type_vector_functions.c' is part of ERT - + Ensemble based Reservoir Tool. + + ERT is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + ERT is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. + + See the GNU General Public License at + for more details. +*/ + +#include +#include + +#include +#include +#include +#include + + +void test_index_list() { + int_vector_type * index_list = int_vector_alloc( 0 , 0 ); + int_vector_append( index_list , 10 ); + int_vector_append( index_list , 20 ); + int_vector_append( index_list , 30 ); + { + bool_vector_type * mask = int_vector_alloc_mask( index_list ); + + test_assert_false( bool_vector_get_default( mask )); + test_assert_int_equal( 31 , bool_vector_size( mask )); + test_assert_true( bool_vector_iget( mask , 10 )); + test_assert_true( bool_vector_iget( mask , 20 )); + test_assert_true( bool_vector_iget( mask , 30 )); + test_assert_int_equal( 3 , bool_vector_count_equal( mask , true )); + + bool_vector_free( mask ); + } + int_vector_free( index_list ); +} + + +void test_mask() { + bool_vector_type * mask = bool_vector_alloc(0 , false); + + bool_vector_iset(mask , 10, true); + bool_vector_iset(mask , 15, true); + bool_vector_iset(mask , 20, true); + + { + int_vector_type * index_list = bool_vector_alloc_active_list( mask ); + + test_assert_int_equal( 3 , int_vector_size( index_list )); + test_assert_int_equal( 10 , int_vector_iget( index_list , 0 )); + test_assert_int_equal( 15 , int_vector_iget( index_list , 1 )); + test_assert_int_equal( 20 , int_vector_iget( index_list , 2 )); + + int_vector_free( index_list ); + } + bool_vector_free( mask ); +} + + +void test_active_index_list() { + int default_value = -1; + bool_vector_type * mask = bool_vector_alloc(0 , false); + + bool_vector_iset(mask , 10, true); + bool_vector_iset(mask , 15, true); + bool_vector_iset(mask , 20, true); + + { + int_vector_type * active_index_list = bool_vector_alloc_active_index_list(mask , default_value); + + test_assert_int_equal( default_value , int_vector_get_default(active_index_list)); + test_assert_int_equal( 21 , int_vector_size( active_index_list )); + + test_assert_int_equal( default_value , int_vector_iget( active_index_list , 0)); + test_assert_int_equal( default_value , int_vector_iget( active_index_list , 1)); + test_assert_int_equal( default_value , int_vector_iget( active_index_list , 12)); + test_assert_int_equal( default_value , int_vector_iget( active_index_list , 19)); + + test_assert_int_equal( 0 , int_vector_iget( active_index_list , 10)); + test_assert_int_equal( 1 , int_vector_iget( active_index_list , 15)); + test_assert_int_equal( 2 , int_vector_iget( active_index_list , 20)); + + + int_vector_free( active_index_list); + } + bool_vector_free(mask); +} + + +int main( int argc , char ** argv) { + test_index_list(); + test_mask(); + test_active_index_list(); + exit(0); +} diff --git a/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_test.c b/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_test.c index a3d44d5c3e..f2733a2176 100644 --- a/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_test.c +++ b/ThirdParty/Ert/devel/libert_util/tests/ert_util_type_vector_test.c @@ -39,6 +39,20 @@ void test_div() { } +void test_alloc() { + const int size = 100; + const int default_value = 77; + int_vector_type * v = int_vector_alloc(size , default_value); + + test_assert_int_equal(size , int_vector_size(v)); + for (int i=0; i < size; i++) + test_assert_int_equal( default_value , int_vector_iget( v , i)); + + + int_vector_free( v); +} + + int main(int argc , char ** argv) { @@ -112,7 +126,7 @@ int main(int argc , char ** argv) { int_vector_free( v1 ); int_vector_free( v2 ); } - + test_alloc(); test_div(); exit(0); } diff --git a/ThirdParty/Ert/devel/librms/src/makefile b/ThirdParty/Ert/devel/librms/src/makefile new file mode 100644 index 0000000000..79b8e2f27f --- /dev/null +++ b/ThirdParty/Ert/devel/librms/src/makefile @@ -0,0 +1,74 @@ +include global_config +SDP_ROOT = $(shell get_sdp_root.py) +################################################################# +COMPILE_INCLUDE = -I$(LIBRMS_HOME)/src -I$(LIBECL_HOME)/include -I$(LIBUTIL_HOME)/include +INSTALL_INC_PATH = $(LIBRMS_HOME)/include +INSTALL_LIB_PATH = $(LIBRMS_HOME)/lib +################################################################# +OBJECTS = rms_file.o rms_util.o rms_tag.o rms_type.o rms_tagkey.o rms_stats.o rms_export.o +INC_FILES = rms_file.h rms_util.h rms_tag.h rms_type.h rms_tagkey.h rms_stats.h rms_export.h +LIB = librms.a + + +LOCAL: LIB + install -d $(INSTALL_INC_PATH) + install -d $(INSTALL_LIB_PATH) + install $(INC_FILES) $(INSTALL_INC_PATH) + install $(LIB) $(INSTALL_LIB_PATH) + +SDP_INSTALL: LIB BIN + install $(LIB) $(SDP_ROOT)/lib/lib$(LIB_ROOT).a + install $(INC_FILES) $(SDP_ROOT)/include + +LIB: $(LIB) + +clean: + rm -f *.o *~ + rm -f $(LIB) + rm -f $(INSTALL_LIB_PATH)/$(LIB) + rm -f $(INSTALL_INC_PATH)/*.h + +rebuild: clean LOCAL + +$(LIB): $(OBJECTS) + $(AR) $(ARFLAGS) $(LIB) $(OBJECTS) + + +%.o : %.c + $(CC) -c $(CFLAGS) $(COMPILE_INCLUDE) $(CPPFLAGS) $< -o $@ + + +new: + ../../Scripts/cdep.py all_include.h 0 + +include dependencies + +################################################################## +## Binaries +# +#BIN_FILES = rms.x rms_stat.x roff_tags.x rms_extract.x rms_setname.x +#BIN: $(BIN_FILES) +#BIN_FILES_SDP_INSTALL = roff_tags.x +# +#rms_test.o : rms_test.c +#rms_stat.o : rms_stat.c +#tag_list.o : tag_list.c +#rms_extract.o : rms_extract.c +#rms_setname.o : rms_setname.c +# +#roff_tags.x: tag_list.o $(LIB) +# $(CC) -$(MFLAG) $(LDFLAGS) tag_list.o -o roff_tags.x $(LIB_PATH) $(LIB_LINK) +# +#rms.x: rms_test.o $(LIB) +# $(CC) -$(MFLAG) $(LDFLAGS) rms_test.o -o rms.x $(LIB_PATH) $(LIB_LINK) +# +#rms_stat.x: rms_stat.o $(LIB) +# $(CC) -$(MFLAG) $(LDFLAGS) rms_stat.o -o rms_stat.x $(LIB_PATH) $(LIB_LINK) +# +#rms_extract.x: rms_extract.o $(LIB) +# $(CC) -$(MFLAG) $(LDFLAGS) rms_extract.o -o rms_extract.x $(LIB_PATH) $(LIB_LINK) +# +#rms_setname.x: rms_setname.o $(LIB) +# $(CC) -$(MFLAG) $(LDFLAGS) rms_setname.o -o rms_setname.x $(LIB_PATH) $(LIB_LINK) + + diff --git a/ThirdParty/Ert/devel/python/python/ert/config/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/config/CMakeLists.txt index 337282c11a..c41c147d61 100644 --- a/ThirdParty/Ert/devel/python/python/ert/config/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/python/ert/config/CMakeLists.txt @@ -1,7 +1,8 @@ set(PYTHON_SOURCES __init__.py - config_enums.py + content_type_enum.py config_parser.py + unrecognized_enum.py ) add_python_package("Python ert.config" ${PYTHON_INSTALL_PREFIX}/ert/config "${PYTHON_SOURCES}" True) diff --git a/ThirdParty/Ert/devel/python/python/ert/config/__init__.py b/ThirdParty/Ert/devel/python/python/ert/config/__init__.py index 302cb8031f..557b39abd9 100644 --- a/ThirdParty/Ert/devel/python/python/ert/config/__init__.py +++ b/ThirdParty/Ert/devel/python/python/ert/config/__init__.py @@ -18,6 +18,6 @@ import ert.util CONFIG_LIB = clib.ert_load("libconfig.so") - -from .config_enums import ContentTypeEnum, UnrecognizedEnum -from .config_parser import ConfigParser , SchemaItem , ContentItem , ContentNode \ No newline at end of file +from .unrecognized_enum import UnrecognizedEnum +from .content_type_enum import ContentTypeEnum +from .config_parser import ConfigParser, SchemaItem, ContentItem, ContentNode \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/config/config_parser.py b/ThirdParty/Ert/devel/python/python/ert/config/config_parser.py index e60d45ab44..99137ba53b 100644 --- a/ThirdParty/Ert/devel/python/python/ert/config/config_parser.py +++ b/ThirdParty/Ert/devel/python/python/ert/config/config_parser.py @@ -16,145 +16,141 @@ import os.path -from ert.config import UnrecognizedEnum, CONFIG_LIB -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.config import UnrecognizedEnum, CONFIG_LIB, ContentTypeEnum +from ert.cwrap import BaseCClass, CWrapper -class SchemaItem(CClass): +class SchemaItem(BaseCClass): def __init__(self, keyword, required=False): - c_ptr = cfunc.schema_alloc(keyword, required) - self.init_cref(c_ptr, cfunc.schema_free) + c_ptr = SchemaItem.cNamespace().alloc(keyword, required) + super(SchemaItem, self).__init__(c_ptr) - @classmethod - def wrap(cls, c_ptr, parent): - obj = object.__new__(cls) - obj.init_cref(c_ptr, parent) - return obj - - - def iget_type( self, index ): - return cfunc.schema_iget_type(self, index) + def iget_type( self, index): + """ @rtype: ContentTypeEnum """ + return SchemaItem.cNamespace().iget_type(self, index) def iset_type( self, index, schema_type ): - cfunc.schema_iset_type(self, index, schema_type) + """ + @type schema_type: ContentTypeEnum + """ + assert isinstance(schema_type, ContentTypeEnum) + SchemaItem.cNamespace().iset_type(self, index, schema_type) def set_argc_minmax(self, minimum, maximum): - cfunc.schema_set_argc_minmax(self, minimum, maximum) + SchemaItem.cNamespace().set_argc_minmax(self, minimum, maximum) -#----------------------------------------------------------------- + def free(self): + SchemaItem.cNamespace().free(self) -class ContentItem(CClass): + +class ContentItem(BaseCClass): # Not possible to create new python instances of this class + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - @classmethod - def wrap(cls, c_ptr, parent): - obj = object.__new__(cls) - obj.init_cref(c_ptr, parent) - return obj def __len__(self): - return cfunc.content_size(self) + return ContentItem.cNamespace().size(self) def __getitem__(self, index): if isinstance(index, int): if (index >= 0) and (index < self.__len__()): - c_ptr = cfunc.iget_content_node(self, index) - return ContentNode.wrap(c_ptr, self) + return ContentItem.cNamespace().iget_content_node(self, index).setParent(self) else: raise IndexError else: raise ValueError("[] operator must have integer index") -#----------------------------------------------------------------- - - - -class ContentNode(CClass): +class ContentNode(BaseCClass): # Not possible to create new python instances of this class - @classmethod - def wrap(cls, c_ptr, parent): - obj = object.__new__(cls) - obj.init_cref(c_ptr, parent) - return obj + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") def __len__(self): - return cfunc.content_node_size(self) + return ContentNode.cNamespace().size(self) def __getitem__(self, index): if isinstance(index, int): if (index >= 0) and (index < self.__len__()): - return cfunc.content_node_iget(self, index) + return ContentNode.cNamespace().iget(self, index) else: raise IndexError else: raise ValueError("[] operator must have integer index") def content(self, sep=" "): - return cfunc.content_full_string(self, sep) + return ContentNode.cNamespace().get_full_string(self, sep) -#----------------------------------------------------------------- - - -class ConfigParser(CClass): +class ConfigParser(BaseCClass): def __init__(self): - c_ptr = cfunc.config_alloc() - self.init_cobj(c_ptr, cfunc.config_free) - + c_ptr = ConfigParser.cNamespace().alloc() + super(ConfigParser, self).__init__(c_ptr) def add(self, keyword, required=False): - c_ptr = cfunc.add(self, keyword, required) - schema_item = SchemaItem.wrap(c_ptr, self) - return schema_item + return ConfigParser.cNamespace().add(self, keyword, required).setParent() - - def parse( self, config_file, comment_string="--", include_kw="INCLUDE", define_kw="DEFINE", + def parse(self, config_file, comment_string="--", include_kw="INCLUDE", define_kw="DEFINE", unrecognized=UnrecognizedEnum.CONFIG_UNRECOGNIZED_WARN, validate=True): + + assert isinstance(unrecognized, UnrecognizedEnum) + if os.path.exists(config_file): - return cfunc.parse(self, config_file, comment_string, include_kw, define_kw, unrecognized, validate) + return ConfigParser.cNamespace().parse(self, config_file, comment_string, include_kw, define_kw, unrecognized, validate) else: raise IOError("File: %s does not exists") def __getitem__(self, keyword): - if cfunc.has_content(self, keyword): - c_ptr = cfunc.get_content(self, keyword) - return ContentItem.wrap(c_ptr, self) + if ConfigParser.cNamespace().has_content(self, keyword): + return ConfigParser.cNamespace().get_content(self, keyword).setParent(self) else: return None -#----------------------------------------------------------------- + def free(self): + ConfigParser.cNamespace().free(self) + cwrapper = CWrapper(CONFIG_LIB) cwrapper.registerType("config_parser", ConfigParser) +cwrapper.registerType("config_parser_obj", ConfigParser.createPythonObject) +cwrapper.registerType("config_parser_ref", ConfigParser.createCReference) + cwrapper.registerType("schema_item", SchemaItem) +cwrapper.registerType("schema_item_obj", SchemaItem.createPythonObject) +cwrapper.registerType("schema_item_ref", SchemaItem.createCReference) + cwrapper.registerType("content_item", ContentItem) +cwrapper.registerType("content_item_obj", ContentItem.createPythonObject) +cwrapper.registerType("content_item_ref", ContentItem.createCReference) + cwrapper.registerType("content_node", ContentNode) +cwrapper.registerType("content_node_obj", ContentNode.createPythonObject) +cwrapper.registerType("content_node_ref", ContentNode.createCReference) -cfunc = CWrapperNameSpace("config") +ConfigParser.cNamespace().alloc = cwrapper.prototype("c_void_p config_alloc( )") +ConfigParser.cNamespace().add = cwrapper.prototype("schema_item_ref config_add_schema_item( config_parser , char* , bool)") +ConfigParser.cNamespace().free = cwrapper.prototype("void config_free( config_parser )") +ConfigParser.cNamespace().parse = cwrapper.prototype("bool config_parse( config_parser , char* , char* , char* , char* , config_unrecognized_enum , bool )") +ConfigParser.cNamespace().has_content = cwrapper.prototype("bool config_has_content_item( config_parser , char*) ") +ConfigParser.cNamespace().get_content = cwrapper.prototype("content_item_ref config_get_content_item( config_parser , char*) ") -cfunc.add = cwrapper.prototype("c_void_p config_add_schema_item( config_parser , char* , bool)") -cfunc.config_alloc = cwrapper.prototype("c_void_p config_alloc( )") -cfunc.config_free = cwrapper.prototype("void config_free( config_parser )") -cfunc.parse = cwrapper.prototype("bool config_parse( config_parser , char* , char* , char* , char* , int , bool )") -cfunc.has_content = cwrapper.prototype("bool config_has_content_item( config_parser , char*) ") -cfunc.get_content = cwrapper.prototype("c_void_p config_get_content_item( config_parser , char*) ") +SchemaItem.cNamespace().alloc = cwrapper.prototype("c_void_p config_schema_item_alloc( char* , bool )") +SchemaItem.cNamespace().free = cwrapper.prototype("void config_schema_item_free( schema_item )") +SchemaItem.cNamespace().iget_type = cwrapper.prototype("config_content_type_enum config_schema_item_iget_type( schema_item, int)") +SchemaItem.cNamespace().iset_type = cwrapper.prototype("void config_schema_item_iset_type( schema_item , int , config_content_type_enum)") +SchemaItem.cNamespace().set_argc_minmax = cwrapper.prototype("void config_schema_item_set_argc_minmax( schema_item , int , int)") -cfunc.schema_alloc = cwrapper.prototype("c_void_p config_schema_item_alloc( char* , bool )") -cfunc.schema_free = cwrapper.prototype("void config_schema_item_free( schema_item )") -cfunc.schema_iget_type = cwrapper.prototype("int config_schema_item_iget_type( schema_item ,int)") -cfunc.schema_iset_type = cwrapper.prototype("void config_schema_item_iset_type( schema_item , int , int)") -cfunc.schema_set_argc_minmax = cwrapper.prototype("void config_schema_item_set_argc_minmax( schema_item , int , int)") +ContentItem.cNamespace().size = cwrapper.prototype("int config_content_item_get_size( content_item )") +ContentItem.cNamespace().iget_content_node = cwrapper.prototype("content_node_ref config_content_item_iget_node( content_item , int)") -cfunc.content_size = cwrapper.prototype("int config_content_item_get_size( content_item )") -cfunc.iget_content_node = cwrapper.prototype("int config_content_item_iget_node( content_item , int)") -cfunc.content_node_iget = cwrapper.prototype("char* config_content_node_iget( content_node , int)") -cfunc.content_node_size = cwrapper.prototype("int config_content_node_get_size( content_node )") -cfunc.content_full_string = cwrapper.prototype("char* config_content_node_get_full_string( content_node , char* )") +ContentNode.cNamespace().iget = cwrapper.prototype("char* config_content_node_iget( content_node , int)") +ContentNode.cNamespace().size = cwrapper.prototype("int config_content_node_get_size( content_node )") +ContentNode.cNamespace().get_full_string = cwrapper.prototype("char* config_content_node_get_full_string( content_node , char* )") diff --git a/ThirdParty/Ert/devel/python/python/ert/config/content_type_enum.py b/ThirdParty/Ert/devel/python/python/ert/config/content_type_enum.py new file mode 100644 index 0000000000..4a10991bf4 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/config/content_type_enum.py @@ -0,0 +1,29 @@ +# Copyright (C) 2013 Statoil ASA, Norway. +# +# The file 'content_type_enum.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. + +from ert.cwrap import BaseCEnum +from ert.config import CONFIG_LIB + + +class ContentTypeEnum(BaseCEnum): + pass + + +ContentTypeEnum.populateEnum(CONFIG_LIB, "config_schema_item_type_enum_iget") +ContentTypeEnum.registerEnum(CONFIG_LIB, "config_content_type_enum") + + + diff --git a/ThirdParty/Ert/devel/python/python/ert/config/unrecognized_enum.py b/ThirdParty/Ert/devel/python/python/ert/config/unrecognized_enum.py new file mode 100644 index 0000000000..59fd0da333 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/config/unrecognized_enum.py @@ -0,0 +1,24 @@ +# Copyright (C) 2013 Statoil ASA, Norway. +# +# The file 'unrecognized_enum.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. + +from ert.cwrap import BaseCEnum +from ert.config import CONFIG_LIB + +class UnrecognizedEnum(BaseCEnum): + pass + +UnrecognizedEnum.populateEnum(CONFIG_LIB, "config_schema_item_unrecognized_enum_iget") +UnrecognizedEnum.registerEnum(CONFIG_LIB, "config_unrecognized_enum") diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/cwrap/CMakeLists.txt index e05fd016d3..181d47a9d1 100644 --- a/ThirdParty/Ert/devel/python/python/ert/cwrap/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/CMakeLists.txt @@ -1,9 +1,12 @@ set(PYTHON_SOURCES __init__.py + basecclass.py + basecenum.py cclass.py cenum.py cfile.py clib.py + cnamespace.py cwrap.py ) diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/__init__.py b/ThirdParty/Ert/devel/python/python/ert/cwrap/__init__.py index 062953444e..2212fb03e9 100644 --- a/ThirdParty/Ert/devel/python/python/ert/cwrap/__init__.py +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/__init__.py @@ -43,4 +43,9 @@ from .cclass import CClass from .cenum import create_enum from .cfile import CFILE from .clib import load, ert_lib_path, ert_load -from .cwrap import CWrapper, CWrapperNameSpace \ No newline at end of file +from .cwrap import CWrapper, CWrapperNameSpace + +from .cnamespace import CNamespace +from .basecclass import BaseCClass +from .basecenum import BaseCEnum + diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/basecclass.py b/ThirdParty/Ert/devel/python/python/ert/cwrap/basecclass.py new file mode 100644 index 0000000000..25ad1d7ecc --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/basecclass.py @@ -0,0 +1,78 @@ +import ctypes +from ert.cwrap import CNamespace + + +class BaseCClass(object): + namespaces = {} + + def __init__(self, c_pointer, parent=None, is_reference=False): + self._c_pointer = None + self._parent = None + self._is_reference = False + + if not c_pointer > 0: + raise ValueError("Must have a valid pointer value!") + + self._c_pointer = c_pointer + self._parent = parent + self._is_reference = is_reference + + + @classmethod + def cNamespace(cls): + """ @rtype: CNamespace """ + if not BaseCClass.namespaces.has_key(cls): + BaseCClass.namespaces[cls] = CNamespace(cls.__name__) + return BaseCClass.namespaces[cls] + + @classmethod + def from_param(cls, c_class_object): + if not isinstance(c_class_object, BaseCClass): + raise ValueError("c_class_object must be an BaseCClass instance!") + + if c_class_object is None or not hasattr(c_class_object, "_c_pointer"): + return ctypes.c_void_p() + else: + return ctypes.c_void_p(c_class_object._c_pointer) + + @classmethod + def createPythonObject(cls, c_pointer): + if not c_pointer == 0: + new_obj = cls.__new__(cls) + BaseCClass.__init__(new_obj, c_pointer=c_pointer, parent=None, is_reference=False) + return new_obj + return None + + @classmethod + def createCReference(cls, c_pointer, parent=None): + if not c_pointer == 0: + new_obj = cls.__new__(cls) + BaseCClass.__init__(new_obj, c_pointer=c_pointer, parent=parent, is_reference=True) + return new_obj + return None + + def setParent(self, parent=None): + if self._is_reference: + self._parent = parent + else: + raise UserWarning("Can only set parent on reference types!") + + return self + + def isReference(self): + """ @rtype: bool """ + return self._is_reference + + def parent(self): + return self._parent + + def free(self): + raise NotImplementedError("A CClass requires a free method implementation!") + + def __del__(self): + if self.free is not None: + if hasattr(self, "_is_reference") and not self._is_reference: + # Important to check the c_pointer; in the case of failed object creation + # we can have a Python object with c_pointer == None. + if self._c_pointer > 0: + self.free() \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/basecenum.py b/ThirdParty/Ert/devel/python/python/ert/cwrap/basecenum.py new file mode 100644 index 0000000000..4a62274df3 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/basecenum.py @@ -0,0 +1,141 @@ +import ctypes +from ert.cwrap import CWrapper + + +class BaseCEnum(object): + enum_namespace = {} + + def __init__(self, *args, **kwargs): + if not self in self.enum_namespace[self.__class__]: + raise NotImplementedError("Can not be instantiated directly!") + + def __new__(cls, *args, **kwargs): + if len(args) == 1: + enum = cls.__resolveEnum(args[0]) + + if enum is None: + raise ValueError("Unknown enum value: %i" % args[0]) + + return enum + else: + obj = super(BaseCEnum, cls).__new__(cls, *args) + obj.name = None + obj.value = None + return obj + + @classmethod + def from_param(cls, c_class_object): + if not isinstance(c_class_object, BaseCEnum): + raise ValueError("c_class_object must be an BaseCEnum instance!") + return c_class_object.value + + @classmethod + def addEnum(cls, name, value): + if not isinstance(value, int): + raise ValueError("Value must be an integer!") + + enum = cls.__new__(cls) + enum.name = name + enum.value = value + + setattr(cls, name, enum) + + if not cls.enum_namespace.has_key(cls): + cls.enum_namespace[cls] = [] + + cls.enum_namespace[cls].append(enum) + + @classmethod + def enums(cls): + return list(cls.enum_namespace[cls]) + + def __eq__(self, other): + if isinstance(other, self.__class__): + return self.value == other.value + + if isinstance(other, int): + return self.value == other + + return False + + def __str__(self): + return self.name + + def __add__(self, other): + self.__assertOtherIsSameType(other) + value = self.value + other.value + return self.__resolveOrCreateEnum(value) + + def __or__(self, other): + self.__assertOtherIsSameType(other) + value = self.value | other.value + return self.__resolveOrCreateEnum(value) + + + def __xor__(self, other): + self.__assertOtherIsSameType(other) + value = self.value ^ other.value + return self.__resolveOrCreateEnum(value) + + def __and__(self, other): + self.__assertOtherIsSameType(other) + value = self.value & other.value + return self.__resolveOrCreateEnum(value) + + @classmethod + def __createEnum(cls, value): + enum = cls.__new__(cls) + enum.name = "Unnamed '%s' enum with value: %i" % (str(cls.__name__), value) + enum.value = value + return enum + + @classmethod + def __resolveOrCreateEnum(cls, value): + enum = cls.__resolveEnum(value) + + if enum is not None: + return enum + + return cls.__createEnum(value) + + @classmethod + def __resolveEnum(cls, value): + for enum in cls.enum_namespace[cls]: + if enum.value == value: + return enum + return None + + def __assertOtherIsSameType(self, other): + assert isinstance(other, self.__class__), "Can only operate on enums of same type: %s =! %s" % ( + self.__class__.__name__, other.__class__.__name__) + + + @classmethod + def populateEnum(cls, library, enum_provider_function): + try: + func = getattr(library, enum_provider_function) + except AttributeError: + raise ValueError("Could not find enum description function:%s - can not load enum:%s." % (enum_provider_function, cls.__name__)) + + func.restype = ctypes.c_char_p + func.argtypes = [ctypes.c_int, ctypes.POINTER(ctypes.c_int)] + + index = 0 + while True: + value = ctypes.c_int() + name = func(index, ctypes.byref(value)) + + if name: + cls.addEnum(name, value.value) + index += 1 + else: + break + + @classmethod + def registerEnum(cls, library, enum_name): + cwrapper = CWrapper(library) + cwrapper.registerType(enum_name, cls) + + + + diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/cclass.py b/ThirdParty/Ert/devel/python/python/ert/cwrap/cclass.py index 419b11ddf8..e1db0e831c 100644 --- a/ThirdParty/Ert/devel/python/python/ert/cwrap/cclass.py +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/cclass.py @@ -16,6 +16,7 @@ import ctypes + class CClass(object): """ Base class used by all the classes wrapping a C 'class'. @@ -86,38 +87,38 @@ class CClass(object): C object. """ - c_ptr = None - cfree = None + c_ptr = None + cfree = None parent = None - + @classmethod - def from_param( cls , obj ): + def from_param( cls, obj ): if obj is None: return ctypes.c_void_p() else: - return ctypes.c_void_p( obj.c_ptr ) + return ctypes.c_void_p(obj.c_ptr) @classmethod - def asPythonObject( cls , c_ptr, cfree): + def asPythonObject( cls, c_ptr, cfree): assert cfree is not None - obj = cls( ) - obj.init_cobj( c_ptr , cfree) + obj = cls() + obj.init_cobj(c_ptr, cfree) return obj @classmethod - def asPythonReference( cls , c_ptr , parent ): - obj = cls( ) - obj.init_cref( c_ptr , parent ) + def asPythonReference( cls, c_ptr, parent ): + obj = cls() + obj.init_cref(c_ptr, parent) return obj - def init_cref(self , c_ptr , parent): + def init_cref(self, c_ptr, parent): self.c_ptr = c_ptr self.parent = parent self.cfree = None - def init_cobj( self , c_ptr , cfree): + def init_cobj( self, c_ptr, cfree): self.c_ptr = c_ptr self.parent = None self.cfree = cfree @@ -128,5 +129,5 @@ class CClass(object): # Important to check the c_ptr; in the case of failed object creation # we can have a Python object with c_ptr == None. if self.c_ptr: - self.cfree( self ) + self.cfree(self) diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/cnamespace.py b/ThirdParty/Ert/devel/python/python/ert/cwrap/cnamespace.py new file mode 100644 index 0000000000..ed045d1614 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/cnamespace.py @@ -0,0 +1,25 @@ +class CNamespace(object): + def __init__(self, name): + object.__setattr__(self, "_name", name) + object.__setattr__(self, "_functions", {}) + + def __str__(self): + return "%s wrapper" % self._name + + def __setitem__(self, key, value): + self.__setValue(key, value) + + + def __getitem__(self, item): + return self._functions[item] + + def __setattr__(self, key, value): + self.__setValue(key, value) + + def __setValue(self, key, value): + assert not hasattr(self, key), "The namespace %s already contains a function named %s!" % (self._name, key) + + self._functions[key] = value + object.__setattr__(self, key, value) + + diff --git a/ThirdParty/Ert/devel/python/python/ert/cwrap/cwrap.py b/ThirdParty/Ert/devel/python/python/ert/cwrap/cwrap.py index a94bf5ddb3..8761e927a3 100644 --- a/ThirdParty/Ert/devel/python/python/ert/cwrap/cwrap.py +++ b/ThirdParty/Ert/devel/python/python/ert/cwrap/cwrap.py @@ -25,57 +25,56 @@ import re import sys -prototype_pattern = "(?P[a-zA-Z][a-zA-Z0-9_*]*) +(?P[a-zA-Z]\w*) *[(](?P[a-zA-Z0-9_*, ]*)[)]" +prototype_pattern = "(?P[a-zA-Z][a-zA-Z0-9_*]*) +(?P[a-zA-Z]\w*) *[(](?P[a-zA-Z0-9_*, ]*)[)]" class CWrapper: # Observe that registered_types is a class attribute, shared # between all CWrapper instances. registered_types = {} - pattern = re.compile( prototype_pattern ) + pattern = re.compile(prototype_pattern) - def __init__( self , lib ): + def __init__( self, lib ): self.lib = lib @classmethod - def registerType(cls, type, value ): + def registerType(cls, type_name, value): """Register a type against a legal ctypes type""" - cls.registered_types[type] = value + cls.registered_types[type_name] = value @classmethod def registerDefaultTypes(cls): """Registers the default available types for prototyping.""" - cls.registerType("void" , None) - cls.registerType("c_ptr" , ctypes.c_void_p) - cls.registerType("int" , ctypes.c_int) - cls.registerType("int*" , ctypes.POINTER(ctypes.c_int)) - cls.registerType("size_t" , ctypes.c_size_t) - cls.registerType("size_t*" , ctypes.POINTER(ctypes.c_size_t)) - cls.registerType("bool" , ctypes.c_int) - cls.registerType("bool*" , ctypes.POINTER(ctypes.c_int)) - cls.registerType("long" , ctypes.c_long) - cls.registerType("long*" , ctypes.POINTER(ctypes.c_long)) - cls.registerType("char" , ctypes.c_char) - cls.registerType("char*" , ctypes.c_char_p) - cls.registerType("char**" , ctypes.POINTER(ctypes.c_char_p)) - cls.registerType("float" , ctypes.c_float) - cls.registerType("float*" , ctypes.POINTER(ctypes.c_float)) - cls.registerType("double" , ctypes.c_double) - cls.registerType("double*" , ctypes.POINTER(ctypes.c_double)) + cls.registerType("void", None) + cls.registerType("c_ptr", ctypes.c_void_p) + cls.registerType("int", ctypes.c_int) + cls.registerType("int*", ctypes.POINTER(ctypes.c_int)) + cls.registerType("size_t", ctypes.c_size_t) + cls.registerType("size_t*", ctypes.POINTER(ctypes.c_size_t)) + cls.registerType("bool", ctypes.c_int) + cls.registerType("bool*", ctypes.POINTER(ctypes.c_int)) + cls.registerType("long", ctypes.c_long) + cls.registerType("long*", ctypes.POINTER(ctypes.c_long)) + cls.registerType("char", ctypes.c_char) + cls.registerType("char*", ctypes.c_char_p) + cls.registerType("char**", ctypes.POINTER(ctypes.c_char_p)) + cls.registerType("float", ctypes.c_float) + cls.registerType("float*", ctypes.POINTER(ctypes.c_float)) + cls.registerType("double", ctypes.c_double) + cls.registerType("double*", ctypes.POINTER(ctypes.c_double)) - - def __parseType(self, type): + def __parseType(self, type_name): """Convert a prototype definition type from string to a ctypes legal type.""" - type = type.strip() + type_name = type_name.strip() - if CWrapper.registered_types.has_key(type): - return CWrapper.registered_types[type] + if CWrapper.registered_types.has_key(type_name): + return CWrapper.registered_types[type_name] else: - return getattr(ctypes , type) + return getattr(ctypes, type_name) - - def prototype(self, prototype , lib = None): + + def prototype(self, prototype, lib=None): """ Defines the return type and arguments for a C-function @@ -110,7 +109,7 @@ class CWrapper: functioname = match.groupdict()["function"] arguments = match.groupdict()["arguments"].split(",") - func = getattr(self.lib , functioname) + func = getattr(self.lib, functioname) func.restype = self.__parseType(restype) if len(arguments) == 1 and arguments[0].strip() == "": @@ -123,26 +122,26 @@ class CWrapper: return func - def safe_prototype(self,pattern , lib = None): + def safe_prototype(self, pattern, lib=None): try: func = self.prototype(pattern, lib) except AttributeError: func = None sys.stderr.write("****Defunct function call: %s\n" % pattern) return func - - + + def print_types(self): for ctype in self.registered_types.keys(): - print "%16s -> %s" % (ctype , self.registered_types[ ctype ]) - + print "%16s -> %s" % (ctype, self.registered_types[ctype]) class CWrapperNameSpace: - def __init__( self , name ): + def __init__( self, name ): self.name = name - + def __str__(self): return "%s wrapper" % self.name + CWrapper.registerDefaultTypes() diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/ecl/CMakeLists.txt index 6a1cb0f0ac..c1cf6d090a 100644 --- a/ThirdParty/Ert/devel/python/python/ert/ecl/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/CMakeLists.txt @@ -12,8 +12,11 @@ SET(PYTHON_SOURCES ecl_region.py ecl_rft.py ecl_rft_cell.py + ecl_smspec_node.py ecl_subsidence.py ecl_sum.py + ecl_sum_node.py + ecl_sum_vector.py ecl_util.py fortio.py diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_case.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_case.py index e72d958d04..9afa6cb2fb 100644 --- a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_case.py +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_case.py @@ -21,7 +21,7 @@ C based functions. """ import os import warnings -from ert.ecl import EclRFTFile, EclGrid, EclSum, EclUtil +from ert.ecl import EclRFTFile, EclGrid, EclSum, EclUtil, EclDefault, EclQueue @@ -192,17 +192,17 @@ class EclCase: argv = [ecl_version , self.datafile , num_cpu] if ecl_cmd is None: - ecl_cmd = ecl_default.default.ecl_cmd + ecl_cmd = EclDefault.ecl_cmd() if driver_type is None: - driver_type = ECL_DEFAULT.driver_type + driver_type = EclDefault.driver_type() if ecl_version is None: - ecl_version = ECL_DEFAULT.ecl_version + ecl_version = EclDefault.ecl_version() if driver is None: if driver_options is None: - driver_options = ECL_DEFAULT.driver_options[ driver_type ] + driver_options = EclDefault.driver_options()[ driver_type ] driver = queue_driver.Driver( driver_type , max_running = 0 , options = driver_options ) job = driver.submit( self.base , ecl_cmd , self.path , argv , blocking = blocking) return job @@ -222,5 +222,7 @@ class EclCase: The @queue argument should be an existing EclQueue() instance which will collect the jobs, and pass them on to a driver when there is free capacity. + + @type queue: EclQueue """ - queue.submit( self.datafile ) + queue.submitDatafile( self.datafile ) diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_queue.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_queue.py index 840d35e3b2..932ecea458 100644 --- a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_queue.py +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_queue.py @@ -157,10 +157,10 @@ class EclQueue(JobQueue): driver_options = EclDefault.driver_options()[driver_type] driver = Driver(driver_type, max_running=max_running, options=driver_options) - JobQueue.__init__(self, driver, size=size) + super(EclQueue, self).__init__(driver, size=size) - def submit( self, data_file): + def submitDataFile(self, data_file): """ Will submit a new simulation of case given by @data_file. @@ -173,5 +173,5 @@ class EclQueue(JobQueue): num_cpu = EclUtil.get_num_cpu(data_file) argv = [self.ecl_version, path_base, "%s" % num_cpu] - return JobQueue.submit(self, self.ecl_cmd, run_path, base, argv, num_cpu=num_cpu) + return super(EclQueue, self).submit(self.ecl_cmd, run_path, base, argv, num_cpu=num_cpu) diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_region.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_region.py index 300a065bad..57a4b2ff78 100644 --- a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_region.py +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_region.py @@ -818,8 +818,10 @@ class EclRegion(CClass): """ IntVector instance with global indices in the region. """ - c_ptr = cfunc.get_global_list( self ) - global_list = IntVector.asPythonReference( c_ptr , self ) + # c_ptr = cfunc.get_global_list( self ) + # global_list = IntVector.asPythonReference( c_ptr , self ) + global_list = cfunc.get_global_list(self) + global_list.setParent(self) return global_list @property @@ -930,7 +932,7 @@ cfunc.xor = cwrapper.prototype("void ecl_region_xor( ecl_ cfunc.get_kw_index_list = cwrapper.prototype("c_void_p ecl_region_get_kw_index_list( ecl_region , ecl_kw , bool )") cfunc.get_active_list = cwrapper.prototype("c_void_p ecl_region_get_active_list( ecl_region )") -cfunc.get_global_list = cwrapper.prototype("c_void_p ecl_region_get_global_list( ecl_region )") +cfunc.get_global_list = cwrapper.prototype("int_vector_ref ecl_region_get_global_list( ecl_region )") cfunc.get_active_global = cwrapper.prototype("c_void_p ecl_region_get_global_active_list( ecl_region )") cfunc.select_cmp_less = cwrapper.prototype("void ecl_region_cmp_select_less( ecl_region , ecl_kw , ecl_kw)") diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_smspec_node.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_smspec_node.py new file mode 100644 index 0000000000..278c12ab0d --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_smspec_node.py @@ -0,0 +1,122 @@ +from ert.cwrap import BaseCClass, CWrapper +from ert.ecl import ECL_LIB + + +class EclSMSPECNode(BaseCClass): + """ + Small class with some meta information about a summary variable. + + The summary variables have different attributes, like if they + represent a total quantity, a rate or a historical quantity. These + quantities, in addition to the underlying values like WGNAMES, + KEYWORD and NUMS taken from the the SMSPEC file are stored in this + structure. + """ + + def __init__(self): + super(EclSMSPECNode, self).__init__(0) # null pointer + raise NotImplementedError("Class can not be instantiated directly!") + + @property + def is_total(self): + """ + Will check if the node corresponds to a total quantity. + + The question of whether a variable corresponds to a 'total' + quantity or not can be interesting for e.g. interpolation + purposes. The actual question whether a quantity is total or + not is based on a hardcoded list in smspec_node_set_flags() in + smspec_node.c; this list again is based on the tables 2.7 - + 2.11 in the ECLIPSE fileformat documentation. + """ + return EclSMSPECNode.cNamespace().node_is_total(self) + + @property + def is_rate(self): + """ + Will check if the variable in question is a rate variable. + + The conecpt of rate variabel is important (internally) when + interpolation values to arbitrary times. + """ + return EclSMSPECNode.cNamespace().node_is_rate(self) + + + @property + def is_historical(self): + """ + Checks if the key corresponds to a historical variable. + + The check is only based on the last character; all variables + ending with 'H' are considered historical. + """ + return EclSMSPECNode.cNamespace().node_is_historical(self) + + + @property + def unit(self): + """ + Returns the unit of this node as a string. + """ + return EclSMSPECNode.cNamespace().node_unit(self) + + @property + def wgname(self): + """ + Returns the WGNAME property for this node. + + Many variables do not have the WGNAME property, i.e. the field + related variables like FOPT and the block properties like + BPR:10,10,10. For these variables the function will return + None, and not the ECLIPSE dummy value: ":+:+:+:+". + """ + return EclSMSPECNode.cNamespace().node_wgname(self) + + + @property + def keyword(self): + """ + Returns the KEYWORD property for this node. + + The KEYWORD property is the main classification property in + the ECLIPSE SMSPEC file. The properties of a variable can be + read from the KEWYORD value; see table 3.4 in the ECLIPSE file + format reference manual. + """ + return EclSMSPECNode.cNamespace().node_keyword(self) + + @property + def num(self): + """ + Returns the NUMS value for this keyword; or None. + + Many of the summary keywords have an integer stored in the + vector NUMS as an attribute, i.e. the block properties have + the global index of the cell in the nums vector. If the + variable in question makes use of the NUMS value this property + will return the value, otherwise it will return None: + + sum.smspec_node("FOPT").num => None + sum.smspec_node("BPR:1000").num => 1000 + """ + if EclSMSPECNode.cNamespace().node_need_num(self): + return EclSMSPECNode.cNamespace().node_num(self) + else: + return None + + + +cwrapper = CWrapper(ECL_LIB) + +cwrapper.registerType("smspec_node", EclSMSPECNode) +cwrapper.registerType("smspec_node_obj", EclSMSPECNode.createPythonObject) +cwrapper.registerType("smspec_node_ref", EclSMSPECNode.createCReference) + +EclSMSPECNode.cNamespace().node_is_total = cwrapper.prototype("bool smspec_node_is_total( smspec_node )") +EclSMSPECNode.cNamespace().node_is_historical = cwrapper.prototype("bool smspec_node_is_historical( smspec_node )") +EclSMSPECNode.cNamespace().node_is_rate = cwrapper.prototype("bool smspec_node_is_rate( smspec_node )") +EclSMSPECNode.cNamespace().node_unit = cwrapper.prototype("char* smspec_node_get_unit( smspec_node )") +EclSMSPECNode.cNamespace().node_wgname = cwrapper.prototype("char* smspec_node_get_wgname( smspec_node )") +EclSMSPECNode.cNamespace().node_keyword = cwrapper.prototype("char* smspec_node_get_keyword( smspec_node )") +EclSMSPECNode.cNamespace().node_num = cwrapper.prototype("int smspec_node_get_num( smspec_node )") +EclSMSPECNode.cNamespace().node_need_num = cwrapper.prototype("bool smspec_node_need_nums( smspec_node )") \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum.py index e335cce4c0..3fc033aefd 100644 --- a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum.py +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum.py @@ -25,7 +25,9 @@ libecl/src directory. # regarding order of arguments: The C code generally takes the time # index as the first argument and the key/key_index as second # argument. In the python code this order has been reversed. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import BaseCClass, CWrapper +from ert.ecl.ecl_sum_vector import EclSumVector +from ert.ecl.ecl_smspec_node import EclSMSPECNode from ert.util import StringList, ctime, DoubleVector, TimeVector from ert.ecl import ECL_LIB @@ -72,439 +74,9 @@ def date2num( dt ): return base +class EclSum(BaseCClass): -class EclSumNode: - def __init__(self , mini_step , report_step , days , date , mpl_date , value): - """ - EclSumNode is a 'struct' with a summary value and time. - - EclSumNode - a small 'struct' with a summary value and time in - several formats. When iterating over a EclSumVector instance - you will get EclSumNode instances. The content of the - EclSumNode type is stored as plain attributes: - - value : The actual value - report_step : The report step - mini_step : The ministep - days : Days since simulation start - date : The simulation date - mpl_date : A date format suitable for matplotlib - - """ - self.value = value - self.report_step = report_step - self.mini_step = mini_step - self.days = days - self.date = date - self.mpl_date = mpl_date - - def __str__(self): - return "" % ( self.days , self.value ) - - -class EclSumVector: - def __init__(self , parent , key , report_only): - """ - A summary vector with a vector of values and time. - - A summary vector contains the the full time history of one - key, along with the corresponding time vectors in several - different time formats. Depending on the report_only argument - the data vectors in the EclSumVector can either contain all - the time values, or only those corresponding to report_steps. - - The EclSumVector contains a reference to the parent EclSum - structure and this is used to implement several of the - properties and methods of the object; the EclSum vector - instances should therefor only be instantiated through the - EclSum.get_vector() method, and not manually with the - EclSumVector() constructor. - """ - self.parent = parent - self.key = key - self.report_only = report_only - - self.__dates = parent.get_dates( report_only ) - self.__days = parent.get_days( report_only ) - self.__mpl_dates = parent.get_mpl_dates( report_only ) - self.__mini_step = parent.get_mini_step( report_only ) - self.__report_step = parent.get_report_step( report_only ) - self.__values = None - - - def __str__(self): - return "" % self.key - - - @property - def unit( self ): - """ - The unit of this vector. - """ - return self.parent.get_unit( self.key ) - - def assert_values( self ): - """ - This function will load and internalize all the values. - """ - if self.__values == None: - self.__values = self.parent.get_values( self.key , self.report_only ) - - @property - def values( self ): - """ - All the summary values of the vector, as a numpy vector. - """ - self.assert_values( ) - return self.__values - - @property - def dates( self ): - """ - All the dates of the vector, list of datetime() instances. - """ - return self.__dates - - @property - def days( self ): - """ - The time in days as a numpy vector. - - In the case of lab unit this will be hours. - """ - return self.__days - - @property - def mpl_dates( self ): - """ - All the dates as numpy vector of dates in matplotlib format. - """ - return self.__mpl_dates - - @property - def mini_step( self ): - """ - All the ministeps of the vector. - - Ministeps is the ECLIPSE notion of timesteps. The ministeps - are numbered sequentially starting at zero; if you have loaded - the entire simulation the ministep number will correspond to - the natural indexing. The length of each ministep is - determined by the convergence properties of the ECLIPSE - simulation. - """ - return self.__mini_step - - @property - def report_step( self ): - """ - All the report_step of the vector. - """ - return self.__report_step - - - def __iget__( self , index ): - """ - Will return an EclSumNode for element @index; should be called - through the [] operator, otherwise you can come across - unitialized data. - """ - return EclSumNode( self.__mini_step[index] , - self.__report_step[index] , - self.__days[index] , - self.__dates[index] , - self.__mpl_dates[index] , - self.__values[index]) - - - def __len__(self): - """ - The length of the vector - used for the len() builtin. - """ - return len(self.__days) - - - def __getitem__(self , index): - """ - Implements the [] operator. - - Will return EclSumNode instance according to @index. The index - value will be interpreted as in a normal python [] lookup, - i.e. negative values will be interpreted as starting from the - right and also slice notation is allowed[*]. - - [*] Observe that in the case of slices the return value will - not be a proper EclSumVector instance, but rather a normal - Python list of EclSumNode instances. - """ - self.assert_values( ) - length = len( self.values ) - if isinstance( index, int): - if index < 0: - index += len(self.__values) - if index < 0 or index > length: - raise KeyError("Invalid index:%d out of range [0:%d)" % ( index , length)) - else: - return self.__iget__( index ) - elif isinstance( index , slice ): - # Observe that the slice based lookup does __not__ return - # a proper EclSumVector instance; it will merely return - # a simple Python list with EclSumNode instances. - (start , stop , step) = index.indices( length ) - index = start - sub_vector = [] - while index < stop: - sub_vector.append( self.__iget__(index) ) - index += step - return sub_vector - - raise KeyError("Invalid index:%s - must have integer or slice." % index) - - @property - def first( self ): - """ - Will return the first EclSumNode in this vector. - """ - self.assert_values( ) - return self.__iget__( 0 ) - - @property - def last( self ): - """ - Will return the last EclSumNode in this vector. - """ - self.assert_values( ) - - index = len(self.__values) - 1 - return self.__iget__( index ) - - @property - def last_value( self ): - """ - Will return the last value in this vector. - """ - self.assert_values( ) - - index = len(self.__values) - 1 - return self.__iget__( index ).value - - - - def get_interp( self , days = None , date = None): - """ - Will lookup value interpolated to @days or @date. - - The function requires one, and only one, time indicator in - terms of @days or @date. If the @date variable is given that - should be Python datetime instance. - - vec = sum["WWCT:A-3"] - vec.get_interp( days = 100 ) - vec.get_interp( date = datetime.date( year , month , day )) - - This function will crash and burn if the time arguments are - invalid; if in doubt you should check first. - """ - return self.parent.get_interp( self.key , days , date ) - - - def get_interp_vector( self , days_list = None , date_list = None): - """ - Will return Python list of interpolated values. - - See get_interp() for further details. - """ - return self.parent.get_interp_vector( self.key , days_list , date_list ) - - - def get_from_report( self , report_step ): - """ - Will lookup the value based on @report_step. - """ - return self.parent.get_from_report( self.key , report_step ) - - ################################################################# - - def first_gt_index( self , limit ): - """ - Locates first index where the value is above @limit. - - Observe that this method will raise an exception if it is - called from a vector instance with report_only = True. - """ - if not self.report_only: - key_index = cfunc.get_general_var_index( self.parent , self.key ) - time_index = cfunc.get_first_gt( self.parent , key_index , limit ) - return time_index - else: - raise Exception("Sorry - first_gt_index() can not be called for vectors with report_only=True") - - def first_gt( self , limit ): - """ - Locate the first EclSumNode where value is above @limit. - - vec = sum["WWCT:A-3"] - w = vec.first_gt( 0.50 ) - print "Water cut above 0.50 in well A-3 at: %s" % w.date - - Uses first_gt_index() internally and can not be called for - vectors with report_only = True. - """ - time_index = self.first_gt_index( limit ) - print time_index - if time_index >= 0: - return self.__iget__( time_index ) - else: - return None - - def first_lt_index( self , limit ): - """ - Locates first index where the value is below @limit. - - See first_gt_index() for further details. - """ - if not self.report_only: - key_index = cfunc.get_general_var_index( self.parent , self.key ) - time_index = cfunc.get_first_lt( self.parent , key_index , limit ) - return time_index - else: - raise Exception("Sorry - first_lt_index() can not be called for vectors with report_only=True") - - def first_lt( self , limit ): - """ - Locates first element where the value is below @limit. - - See first_gt() for further details. - """ - time_index = self.first_lt_index( limit ) - if time_index >= 0: - return self.__iget__( time_index ) - else: - return None - - - #def plot(self): - # sum_plot.plot_vector( self ) - - - - - ################################################################# - - -class EclSMSPECNode( CClass ): - """ - Small class with some meta information about a summary variable. - - The summary variables have different attributes, like if they - represent a total quantity, a rate or a historical quantity. These - quantities, in addition to the underlying values like WGNAMES, - KEYWORD and NUMS taken from the the SMSPEC file are stored in this - structure. - """ - def __new__(cls , c_ptr , parent): - if c_ptr: - obj = object.__new__( cls ) - obj.init_cref( c_ptr , parent ) - return obj - else: - return None - - @property - def is_total(self): - """ - Will check if the node corresponds to a total quantity. - - The question of whether a variable corresponds to a 'total' - quantity or not can be interesting for e.g. interpolation - purposes. The actual question whether a quantity is total or - not is based on a hardcoded list in smspec_node_set_flags() in - smspec_node.c; this list again is based on the tables 2.7 - - 2.11 in the ECLIPSE fileformat documentation. - """ - return cfunc.node_is_total( self ) - - @property - def is_rate(self): - """ - Will check if the variable in question is a rate variable. - - The conecpt of rate variabel is important (internally) when - interpolation values to arbitrary times. - """ - return cfunc.node_is_rate( self ) - - - @property - def is_historical(self): - """ - Checks if the key corresponds to a historical variable. - - The check is only based on the last character; all variables - ending with 'H' are considered historical. - """ - return cfunc.node_is_historical( self ) - - - @property - def unit(self): - """ - Returns the unit of this node as a string. - """ - return cfunc.node_unit( self ) - - @property - def wgname(self): - """ - Returns the WGNAME property for this node. - - Many variables do not have the WGNAME property, i.e. the field - related variables like FOPT and the block properties like - BPR:10,10,10. For these variables the function will return - None, and not the ECLIPSE dummy value: ":+:+:+:+". - """ - return cfunc.node_wgname(self) - - - @property - def keyword(self): - """ - Returns the KEYWORD property for this node. - - The KEYWORD property is the main classification property in - the ECLIPSE SMSPEC file. The properties of a variable can be - read from the KEWYORD value; see table 3.4 in the ECLIPSE file - format reference manual. - """ - return cfunc.node_keyword( self ) - - @property - def num(self): - """ - Returns the NUMS value for this keyword; or None. - - Many of the summary keywords have an integer stored in the - vector NUMS as an attribute, i.e. the block properties have - the global index of the cell in the nums vector. If the - variable in question makes use of the NUMS value this property - will return the value, otherwise it will return None: - - sum.smspec_node("FOPT").num => None - sum.smspec_node("BPR:1000").num => 1000 - """ - if cfunc.node_need_num( self ): - return cfunc.node_num(self) - else: - return None - - - - - - -class EclSum( CClass ): - - def __new__( cls , load_case , join_string = ":" , include_restart = True, c_ptr = None, parent = None): + def __init__(self, load_case , join_string = ":" , include_restart = True): """ Loads a new EclSum instance with summary data. @@ -512,7 +84,7 @@ class EclSum( CClass ): argument @load_case; @load_case should be the basename of the ECLIPSE simulation you want to load. @load_case can contain a leading path component, and also an extension - the latter will be ignored. - + The @join_string is the string used when combining elements from the WGNAMES, KEYWORDS and NUMS vectors into a composit key; with @join_string == ":" the water cut in well OP_1 will @@ -522,62 +94,44 @@ class EclSum( CClass ): loader will, in the case of a restarted ECLIPSE simulation, try to load summary results also from the restarted case. """ - if c_ptr: - obj = object.__new__( cls ) - if parent: - obj.init_cref( c_ptr , parent) - else: - obj.init_cobj( c_ptr , cfunc.free ) - return obj - else: - c_ptr = cfunc.fread_alloc( load_case , join_string , include_restart) - if c_ptr: - obj = object.__new__( cls ) - obj.init_cobj( c_ptr , cfunc.free ) - return obj - else: - return None - + c_pointer = EclSum.cNamespace().fread_alloc( load_case , join_string , include_restart) + assert c_pointer is not None + super(EclSum, self).__init__(c_pointer) - def __init__(self , load_case , join_string = ":" ,include_restart = True , c_ptr = None, parent = None): - """ - Initialize a new EclSum instance. + self._initialize() - See __new__() for further documentation. - """ - self.load_case = load_case - self.join_string = join_string - self.include_restart = include_restart - + + def _initialize(self): # Initializing the time vectors length = self.length - self.__dates = [ 0 ] * length - self.__report_step = numpy.zeros( length , dtype = numpy.int32) - self.__mini_step = numpy.zeros( length , dtype = numpy.int32) - self.__days = numpy.zeros( length ) - self.__mpl_dates = numpy.zeros( length ) - for i in range( length ): - self.__days[i] = cfunc.iget_sim_days( self , i ) - self.__dates[i] = cfunc.iget_sim_time( self , i).datetime() - self.__report_step[i] = cfunc.iget_report_step( self , i ) - self.__mini_step[i] = cfunc.iget_mini_step( self , i ) - self.__mpl_dates[i] = date2num( self.__dates[i] ) + self.__dates = [0] * length + self.__report_step = numpy.zeros(length, dtype=numpy.int32) + self.__mini_step = numpy.zeros(length, dtype=numpy.int32) + self.__days = numpy.zeros(length) + self.__mpl_dates = numpy.zeros(length) + + for i in range(length): + self.__days[i] = EclSum.cNamespace().iget_sim_days(self, i) + self.__dates[i] = EclSum.cNamespace().iget_sim_time(self, i).datetime() + self.__report_step[i] = EclSum.cNamespace().iget_report_step(self, i) + self.__mini_step[i] = EclSum.cNamespace().iget_mini_step(self, i) + self.__mpl_dates[i] = date2num(self.__dates[i]) index_list = self.report_index_list() - length = len( index_list ) - self.__datesR = [ 0 ] * length - self.__report_stepR = numpy.zeros( length , dtype = numpy.int32) - self.__mini_stepR = numpy.zeros( length , dtype = numpy.int32) - self.__daysR = numpy.zeros( length ) - self.__mpl_datesR = numpy.zeros( length ) - for i in range( length ): - time_index = index_list[ i ] - self.__daysR[i] = cfunc.iget_sim_days( self , time_index ) - self.__datesR[i] = cfunc.iget_sim_time( self , time_index).datetime() - self.__report_stepR[i] = cfunc.iget_report_step( self , time_index ) - self.__mini_stepR[i] = cfunc.iget_mini_step( self , time_index ) - self.__mpl_datesR[i] = date2num( self.__datesR[i] ) - + length = len(index_list) + self.__datesR = [0] * length + self.__report_stepR = numpy.zeros(length, dtype=numpy.int32) + self.__mini_stepR = numpy.zeros(length, dtype=numpy.int32) + self.__daysR = numpy.zeros(length) + self.__mpl_datesR = numpy.zeros(length) + + for i in range(length): + time_index = index_list[i] + self.__daysR[i] = EclSum.cNamespace().iget_sim_days(self, time_index) + self.__datesR[i] = EclSum.cNamespace().iget_sim_time(self, time_index).datetime() + self.__report_stepR[i] = EclSum.cNamespace().iget_report_step(self, time_index) + self.__mini_stepR[i] = EclSum.cNamespace().iget_mini_step(self, time_index) + self.__mpl_datesR[i] = date2num(self.__datesR[i]) def get_vector( self , key , report_only = False): @@ -601,7 +155,7 @@ class EclSum( CClass ): last_report = self.last_report index_list = [] for report_step in range( first_report , last_report + 1): - time_index = cfunc.get_report_end( self , report_step ) + time_index = EclSum.cNamespace().get_report_end( self , report_step ) index_list.append( time_index ) return index_list @@ -615,8 +169,7 @@ class EclSum( CClass ): matching the pattern will be returned; the matching is based on fnmatch(), i.e. shell style wildcards. """ - c_ptr = cfunc.create_well_list( self , pattern ) - return StringList( c_ptr = c_ptr ) + return EclSum.cNamespace().create_well_list( self , pattern ) def groups( self , pattern = None ): @@ -627,8 +180,7 @@ class EclSum( CClass ): matching the pattern will be returned; the matching is based on fnmatch(), i.e. shell style wildcards. """ - c_ptr = cfunc.create_group_list( self , pattern ) - return StringList( c_ptr = c_ptr ) + return EclSum.cNamespace().create_group_list( self , pattern ) def get_values( self , key , report_only = False): @@ -641,18 +193,18 @@ class EclSum( CClass ): instance. """ if self.has_key( key ): - key_index = cfunc.get_general_var_index( self , key ) + key_index = EclSum.cNamespace().get_general_var_index( self , key ) if report_only: index_list = self.report_index_list() values = numpy.zeros( len(index_list) ) for i in range(len( index_list)): time_index = index_list[i] - values[i] = cfunc.iiget( self , time_index , key_index ) + values[i] = EclSum.cNamespace().iiget( self , time_index , key_index ) else: - length = cfunc.data_length( self ) + length = EclSum.cNamespace().data_length( self ) values = numpy.zeros( length ) for i in range( length ): - values[i] = cfunc.iiget( self , i , key_index ) + values[i] = EclSum.cNamespace().iiget( self , i , key_index ) return values else: @@ -678,7 +230,7 @@ class EclSum( CClass ): Quite low-level function, should probably rather use a EclSumVector based function? """ - index = cfunc.get_general_var_index( self , key ) + index = EclSum.cNamespace().get_general_var_index( self , key ) if index >= 0: return index else: @@ -723,7 +275,7 @@ class EclSum( CClass ): This is a quite low level function, in most cases it will be natural to go via e.g. an EclSumVector instance. """ - return cfunc.iiget( self , time_index , key_index ) + return EclSum.cNamespace().iiget( self , time_index , key_index ) def iget(self , key , time_index): @@ -740,7 +292,7 @@ class EclSum( CClass ): This is a quite low level function, in most cases it will be natural to go via e.g. an EclSumVector instance. """ - return cfunc.get_general_var( self , time_index , key ) + return EclSum.cNamespace().get_general_var( self , time_index , key ) def __getitem__(self , key): @@ -756,7 +308,7 @@ class EclSum( CClass ): """ Will check if the input date is in the time span [sim_start , sim_end]. """ - return cfunc.check_sim_time( self , ctime(date) ) + return EclSum.cNamespace().check_sim_time( self , ctime(date) ) def get_interp( self , key , days = None , date = None): @@ -777,13 +329,13 @@ class EclSum( CClass ): if date: raise ValueError("Must supply either days or date") else: - if cfunc.check_sim_days( self , days ): - return cfunc.get_general_var_from_sim_days( self , days , key ) + if EclSum.cNamespace().check_sim_days( self , days ): + return EclSum.cNamespace().get_general_var_from_sim_days( self , days , key ) else: raise ValueError("days:%s is outside range of simulation: [%g,%g]" % (days , self.first_day , self.sim_length)) elif date: if self.check_sim_time( date ): - return cfunc.get_general_var_from_sim_time( self , ctime(date) , key ) + return EclSum.cNamespace().get_general_var_from_sim_time( self , ctime(date) , key ) else: raise ValueError("date:%s is outside range of simulation data" % date) else: @@ -801,9 +353,9 @@ class EclSum( CClass ): if date: if days: raise ValueError("Must supply either days or date") - step = cfunc.get_report_step_from_time( self , ctime(date)) + step = EclSum.cNamespace().get_report_step_from_time( self , ctime(date)) elif days: - step = cfunc.get_report_step_from_days( self , days) + step = EclSum.cNamespace().get_report_step_from_days( self , days) return step @@ -812,7 +364,7 @@ class EclSum( CClass ): """ Will return the datetime corresponding to the report_step @report. """ - ctime = cfunc.get_report_time( self , report ) + ctime = EclSum.cNamespace().get_report_time( self , report ) return ctime.date() @@ -839,8 +391,8 @@ class EclSum( CClass ): sim_start = self.first_day index = 0 for days in days_list: - if days >= sim_start and days < sim_length: - vector[index] = cfunc.get_general_var_from_sim_days( self , days , key) + if (days >= sim_start) and (days < sim_length): + vector[index] = EclSum.cNamespace().get_general_var_from_sim_days( self , days , key) else: raise ValueError("Invalid days value") index += 1 @@ -850,8 +402,8 @@ class EclSum( CClass ): vector = numpy.zeros( len(date_list )) index = 0 for date in date_list: - if date >= start_time and date <= end_time: - vector[index] = cfunc.get_general_var_from_sim_time( self , ctime(date) , key) + if (date >= start_time) and (date <= end_time): + vector[index] = EclSum.cNamespace().get_general_var_from_sim_time( self , ctime(date) , key) else: raise ValueError("Invalid date value") index += 1 @@ -864,15 +416,15 @@ class EclSum( CClass ): """ Return summary value of @key at time @report_step. """ - time_index = cfunc.get_report_end( self , report_step ) - return cfunc.get_general_var( self , time_index , key ) + time_index = EclSum.cNamespace().get_report_end( self , report_step ) + return EclSum.cNamespace().get_general_var( self , time_index , key ) def has_key( self , key): """ Check if summary object has key @key. """ - return cfunc.has_key( self, key ) + return EclSum.cNamespace().has_key( self, key ) def smspec_node( self , key ): @@ -885,8 +437,8 @@ class EclSum( CClass ): on. """ if self.has_key( key ): - c_ptr = cfunc.get_var_node( self , key ) - return EclSMSPECNode( c_ptr , self ) + node = EclSum.cNamespace().get_var_node(self, key).setParent(self) + return node else: raise KeyError("Summary case does not have key:%s" % key) @@ -904,7 +456,7 @@ class EclSum( CClass ): """ Will return the case name of the current instance - optionally including path. """ - return cfunc.get_simcase( self ) + return EclSum.cNamespace().get_simcase( self ) @property @@ -913,21 +465,21 @@ class EclSum( CClass ): Will return the path to the current case. Will be None for case in CWD. See also abs_path. """ - return cfunc.get_path( self ) + return EclSum.cNamespace().get_path( self ) @property def base(self): """ Will return the basename of the current case - no path. """ - return cfunc.get_base( self ) + return EclSum.cNamespace().get_base( self ) @property def abs_path(self): """ Will return the absolute path to the current case. """ - return cfunc.get_abs_path( self ) + return EclSum.cNamespace().get_abs_path( self ) #----------------------------------------------------------------- # Here comes functions for getting vectors of the time @@ -1068,13 +620,13 @@ class EclSum( CClass ): """ Returns the number of simulation days for element nr @time_index. """ - return cfunc.iget_sim_days( self , time_index ) + return EclSum.cNamespace().iget_sim_days( self , time_index ) def iget_date(self , time_index): """ Returns the simulation date for element nr @time_index. """ - return cfunc.iget_sim_time( self , time_index ).datetime() + return EclSum.cNamespace().iget_sim_time( self , time_index ).datetime() def iget_report( self , time_index ): """ @@ -1082,7 +634,7 @@ class EclSum( CClass ): One report step will in general contain many ministeps. """ - return cfunc.iget_report_step( self , time_index ) + return EclSum.cNamespace().iget_report_step( self , time_index ) @property @@ -1090,14 +642,14 @@ class EclSum( CClass ): """ The number of timesteps in the dataset. """ - return cfunc.data_length( self ) + return EclSum.cNamespace().data_length( self ) @property def first_day(self): """ The first day we have simulation data for; normally 0. """ - return cfunc.get_first_day( self ) + return EclSum.cNamespace().get_first_day( self ) @property def sim_length( self ): @@ -1107,7 +659,7 @@ class EclSum( CClass ): Will include the length of a leading restart section, irrespective of whether we have data for this or not. """ - return cfunc.sim_length( self ) + return EclSum.cNamespace().sim_length( self ) @property def start_date(self): @@ -1119,7 +671,7 @@ class EclSum( CClass ): returned start_date might be different from the datetime of the first (loaded) timestep. """ - ctime = cfunc.get_start_date( self ) + ctime = EclSum.cNamespace().get_start_date( self ) return ctime.date() @property @@ -1127,7 +679,7 @@ class EclSum( CClass ): """ The date of the last (loaded) time step. """ - ctime = cfunc.get_end_date( self ) + ctime = EclSum.cNamespace().get_end_date( self ) return ctime.date() @property @@ -1135,7 +687,7 @@ class EclSum( CClass ): """ The first date we have data for. """ - ctime = cfunc.get_data_start( self ) + ctime = EclSum.cNamespace().get_data_start( self ) return ctime.date() @@ -1146,7 +698,7 @@ class EclSum( CClass ): See start_date() for further details. """ - ctime = cfunc.get_start_date( self ) + ctime = EclSum.cNamespace().get_start_date( self ) return ctime.datetime() @property @@ -1154,7 +706,7 @@ class EclSum( CClass ): """ The time of the last (loaded) time step. """ - ctime = cfunc.get_end_date( self ) + ctime = EclSum.cNamespace().get_end_date( self ) return ctime.datetime() @property @@ -1162,29 +714,29 @@ class EclSum( CClass ): """ The number of the last report step in the dataset. """ - return cfunc.get_last_report_step( self ) + return EclSum.cNamespace().get_last_report_step( self ) @property def first_report(self): """ The number of the last report step in the dataset. """ - return cfunc.get_first_report_step( self ) + return EclSum.cNamespace().get_first_report_step( self ) def first_gt_index( self , key , limit ): """ Returns the first index where @key is above @limit. """ - key_index = cfunc.get_general_var_index( self , key ) - time_index = cfunc.get_first_lt( self , key_index , limit ) + key_index = EclSum.cNamespace().get_general_var_index( self , key ) + time_index = EclSum.cNamespace().get_first_lt( self , key_index , limit ) return time_index def first_lt_index( self , key , limit ): """ Returns the first index where @key is below @limit. """ - key_index = cfunc.get_general_var_index( self , key ) - time_index = cfunc.get_first_lt( self , key_index , limit ) + key_index = EclSum.cNamespace().get_general_var_index( self , key ) + time_index = EclSum.cNamespace().get_first_lt( self , key_index , limit ) return time_index def first_gt( self , key , limit ): @@ -1215,99 +767,98 @@ class EclSum( CClass ): object. """ s = StringList() - cfunc.select_matching_keys( self , pattern , s ) + EclSum.cNamespace().select_matching_keys( self , pattern , s ) return s.strings def fwrite(self , ecl_case = None): if ecl_case: - cfunc.set_case( self , ecl_case ) - - cfunc.fwrite_sum( self ) + EclSum.cNamespace().set_case( self , ecl_case ) + + EclSum.cNamespace().fwrite_sum( self ) def alloc_time_vector(self, report_only): - c_ptr = cfunc.alloc_time_vector(self, report_only) - v = TimeVector.asPythonObject(c_ptr, TimeVector.free) - return v + return EclSum.cNamespace().alloc_time_vector(self, report_only) def alloc_data_vector(self, data_index, report_only): - c_ptr = cfunc.alloc_data_vector(self, data_index, report_only) - v = DoubleVector.asPythonObject(c_ptr, DoubleVector.free) - return v - + return EclSum.cNamespace().alloc_data_vector(self, data_index, report_only) def get_general_var_index(self, key): - c_ptr = cfunc.get_general_var_index( self , key ) - v = TimeVector.asPythonObject(c_ptr, TimeVector.free) - return v + return EclSum.cNamespace().get_general_var_index( self , key ) -################################################################# + def free(self): + EclSum.cNamespace().free(self) + + @classmethod + def createCReference(cls, c_pointer, parent=None): + result = super(EclSum, cls).createCReference(c_pointer, parent) + result._initialize() + return result + + @classmethod + def createPythonObject(cls, c_pointer): + result = super(EclSum, cls).createPythonObject(c_pointer) + result._initialize() + return result + + + ################################################################# # 2. Creating a wrapper object around the libecl library, # registering the type map : ecl_kw <-> EclKW cwrapper = CWrapper(ECL_LIB) cwrapper.registerType( "ecl_sum" , EclSum ) -cwrapper.registerType( "smspec_node" , EclSMSPECNode ) +cwrapper.registerType( "ecl_sum_obj" , EclSum.createPythonObject ) +cwrapper.registerType( "ecl_sum_ref" , EclSum.createCReference ) # 3. Installing the c-functions used to manipulate ecl_kw instances. # These functions are used when implementing the EclKW class, not # used outside this scope. -cfunc = CWrapperNameSpace("ecl_sum") -cfunc.create_well_list = cwrapper.prototype("c_void_p ecl_sum_alloc_well_list( ecl_sum , char* )") -cfunc.create_group_list = cwrapper.prototype("c_void_p ecl_sum_alloc_group_list( ecl_sum , char* )") -cfunc.fread_alloc = cwrapper.prototype("c_void_p ecl_sum_fread_alloc_case__( char* , char* , bool)") -cfunc.iiget = cwrapper.prototype("double ecl_sum_iget( ecl_sum , int , int)") -cfunc.free = cwrapper.prototype("void ecl_sum_free( ecl_sum )") -cfunc.data_length = cwrapper.prototype("int ecl_sum_get_data_length( ecl_sum )") -cfunc.iget_sim_days = cwrapper.prototype("double ecl_sum_iget_sim_days( ecl_sum , int) ") -cfunc.iget_report_step = cwrapper.prototype("int ecl_sum_iget_report_step( ecl_sum , int) ") -cfunc.iget_mini_step = cwrapper.prototype("int ecl_sum_iget_mini_step( ecl_sum , int) ") -cfunc.iget_sim_time = cwrapper.prototype("time_t ecl_sum_iget_sim_time( ecl_sum , int) ") -cfunc.get_report_end = cwrapper.prototype("int ecl_sum_iget_report_end( ecl_sum , int)") -cfunc.get_general_var = cwrapper.prototype("double ecl_sum_get_general_var( ecl_sum , int , char*)") -cfunc.get_general_var_index = cwrapper.prototype("int ecl_sum_get_general_var_params_index( ecl_sum , char*)") -cfunc.get_general_var_from_sim_days = cwrapper.prototype("double ecl_sum_get_general_var_from_sim_days( ecl_sum , double , char*)") -cfunc.get_general_var_from_sim_time = cwrapper.prototype("double ecl_sum_get_general_var_from_sim_time( ecl_sum , time_t , char*)") -cfunc.get_first_gt = cwrapper.prototype("int ecl_sum_get_first_gt( ecl_sum , int , double )") -cfunc.get_first_lt = cwrapper.prototype("int ecl_sum_get_first_lt( ecl_sum , int , double )") -cfunc.get_start_date = cwrapper.prototype("time_t ecl_sum_get_start_time( ecl_sum )") -cfunc.get_end_date = cwrapper.prototype("time_t ecl_sum_get_end_time( ecl_sum )") -cfunc.get_last_report_step = cwrapper.prototype("int ecl_sum_get_last_report_step( ecl_sum )") -cfunc.get_first_report_step = cwrapper.prototype("int ecl_sum_get_first_report_step( ecl_sum )") -cfunc.iget_report_step = cwrapper.prototype("int ecl_sum_iget_report_step( ecl_sum , int )") -cfunc.select_matching_keys = cwrapper.prototype("void ecl_sum_select_matching_general_var_list( ecl_sum , char* , stringlist )") -cfunc.has_key = cwrapper.prototype("bool ecl_sum_has_general_var( ecl_sum , char* )") -cfunc.check_sim_time = cwrapper.prototype("bool ecl_sum_check_sim_time( ecl_sum , time_t )") -cfunc.check_sim_days = cwrapper.prototype("bool ecl_sum_check_sim_days( ecl_sum , double )") -cfunc.sim_length = cwrapper.prototype("double ecl_sum_get_sim_length( ecl_sum )") -cfunc.get_first_day = cwrapper.prototype("double ecl_sum_get_first_day( ecl_sum )") -cfunc.get_data_start = cwrapper.prototype("time_t ecl_sum_get_data_start( ecl_sum )") -cfunc.get_unit = cwrapper.prototype("char* ecl_sum_get_unit( ecl_sum , char*)") -cfunc.get_simcase = cwrapper.prototype("char* ecl_sum_get_case( ecl_sum )") -cfunc.get_base = cwrapper.prototype("char* ecl_sum_get_base( ecl_sum )") -cfunc.get_path = cwrapper.prototype("char* ecl_sum_get_path( ecl_sum )") -cfunc.get_abs_path = cwrapper.prototype("char* ecl_sum_get_abs_path( ecl_sum )") -cfunc.get_report_step_from_time = cwrapper.prototype("int ecl_sum_get_report_step_from_time( ecl_sum , time_t)") -cfunc.get_report_step_from_days = cwrapper.prototype("int ecl_sum_get_report_step_from_days( ecl_sum , double)") -cfunc.get_report_time = cwrapper.prototype("time_t ecl_sum_get_report_time(ecl_sum , int)") +EclSum.cNamespace().fread_alloc = cwrapper.prototype("c_void_p ecl_sum_fread_alloc_case__( char* , char* , bool)") +EclSum.cNamespace().iiget = cwrapper.prototype("double ecl_sum_iget( ecl_sum , int , int)") +EclSum.cNamespace().free = cwrapper.prototype("void ecl_sum_free( ecl_sum )") +EclSum.cNamespace().data_length = cwrapper.prototype("int ecl_sum_get_data_length( ecl_sum )") +EclSum.cNamespace().iget_sim_days = cwrapper.prototype("double ecl_sum_iget_sim_days( ecl_sum , int) ") +EclSum.cNamespace().iget_report_step = cwrapper.prototype("int ecl_sum_iget_report_step( ecl_sum , int) ") +EclSum.cNamespace().iget_mini_step = cwrapper.prototype("int ecl_sum_iget_mini_step( ecl_sum , int) ") +EclSum.cNamespace().iget_sim_time = cwrapper.prototype("time_t ecl_sum_iget_sim_time( ecl_sum , int) ") +EclSum.cNamespace().get_report_end = cwrapper.prototype("int ecl_sum_iget_report_end( ecl_sum , int)") +EclSum.cNamespace().get_general_var = cwrapper.prototype("double ecl_sum_get_general_var( ecl_sum , int , char*)") +EclSum.cNamespace().get_general_var_index = cwrapper.prototype("int ecl_sum_get_general_var_params_index( ecl_sum , char*)") +EclSum.cNamespace().get_general_var_from_sim_days = cwrapper.prototype("double ecl_sum_get_general_var_from_sim_days( ecl_sum , double , char*)") +EclSum.cNamespace().get_general_var_from_sim_time = cwrapper.prototype("double ecl_sum_get_general_var_from_sim_time( ecl_sum , time_t , char*)") +EclSum.cNamespace().get_first_gt = cwrapper.prototype("int ecl_sum_get_first_gt( ecl_sum , int , double )") +EclSum.cNamespace().get_first_lt = cwrapper.prototype("int ecl_sum_get_first_lt( ecl_sum , int , double )") +EclSum.cNamespace().get_start_date = cwrapper.prototype("time_t ecl_sum_get_start_time( ecl_sum )") +EclSum.cNamespace().get_end_date = cwrapper.prototype("time_t ecl_sum_get_end_time( ecl_sum )") +EclSum.cNamespace().get_last_report_step = cwrapper.prototype("int ecl_sum_get_last_report_step( ecl_sum )") +EclSum.cNamespace().get_first_report_step = cwrapper.prototype("int ecl_sum_get_first_report_step( ecl_sum )") +EclSum.cNamespace().select_matching_keys = cwrapper.prototype("void ecl_sum_select_matching_general_var_list( ecl_sum , char* , stringlist )") +EclSum.cNamespace().has_key = cwrapper.prototype("bool ecl_sum_has_general_var( ecl_sum , char* )") +EclSum.cNamespace().check_sim_time = cwrapper.prototype("bool ecl_sum_check_sim_time( ecl_sum , time_t )") +EclSum.cNamespace().check_sim_days = cwrapper.prototype("bool ecl_sum_check_sim_days( ecl_sum , double )") +EclSum.cNamespace().sim_length = cwrapper.prototype("double ecl_sum_get_sim_length( ecl_sum )") +EclSum.cNamespace().get_first_day = cwrapper.prototype("double ecl_sum_get_first_day( ecl_sum )") +EclSum.cNamespace().get_data_start = cwrapper.prototype("time_t ecl_sum_get_data_start( ecl_sum )") -cfunc.fwrite_sum = cwrapper.prototype("void ecl_sum_fwrite(ecl_sum)") -cfunc.set_case = cwrapper.prototype("void ecl_sum_set_case(ecl_sum, char*)") -cfunc.alloc_time_vector = cwrapper.prototype("c_void_p ecl_sum_alloc_time_vector(ecl_sum, bool)") -cfunc.alloc_data_vector = cwrapper.prototype("c_void_p ecl_sum_alloc_data_vector(ecl_sum, int, bool)") -#----------------------------------------------------------------- -# smspec node related stuff +EclSum.cNamespace().get_unit = cwrapper.prototype("char* ecl_sum_get_unit( ecl_sum , char*)") +EclSum.cNamespace().get_simcase = cwrapper.prototype("char* ecl_sum_get_case( ecl_sum )") +EclSum.cNamespace().get_base = cwrapper.prototype("char* ecl_sum_get_base( ecl_sum )") +EclSum.cNamespace().get_path = cwrapper.prototype("char* ecl_sum_get_path( ecl_sum )") +EclSum.cNamespace().get_abs_path = cwrapper.prototype("char* ecl_sum_get_abs_path( ecl_sum )") +EclSum.cNamespace().get_report_step_from_time = cwrapper.prototype("int ecl_sum_get_report_step_from_time( ecl_sum , time_t)") +EclSum.cNamespace().get_report_step_from_days = cwrapper.prototype("int ecl_sum_get_report_step_from_days( ecl_sum , double)") +EclSum.cNamespace().get_report_time = cwrapper.prototype("time_t ecl_sum_get_report_time(ecl_sum , int)") + +EclSum.cNamespace().fwrite_sum = cwrapper.prototype("void ecl_sum_fwrite(ecl_sum)") +EclSum.cNamespace().set_case = cwrapper.prototype("void ecl_sum_set_case(ecl_sum, char*)") +EclSum.cNamespace().alloc_time_vector = cwrapper.prototype("time_t_vector_obj ecl_sum_alloc_time_vector(ecl_sum, bool)") +EclSum.cNamespace().alloc_data_vector = cwrapper.prototype("double_vector_obj ecl_sum_alloc_data_vector(ecl_sum, int, bool)") +EclSum.cNamespace().get_var_node = cwrapper.prototype("smspec_node_ref ecl_sum_get_general_var_node(ecl_sum , char* )") +EclSum.cNamespace().create_well_list = cwrapper.prototype("stringlist_obj ecl_sum_alloc_well_list( ecl_sum , char* )") +EclSum.cNamespace().create_group_list = cwrapper.prototype("stringlist_obj ecl_sum_alloc_group_list( ecl_sum , char* )") -cfunc.get_var_node = cwrapper.prototype("c_void_p ecl_sum_get_general_var_node(ecl_sum , char* )") -cfunc.node_is_total = cwrapper.prototype("bool smspec_node_is_total( smspec_node )") -cfunc.node_is_historical = cwrapper.prototype("bool smspec_node_is_historical( smspec_node )") -cfunc.node_is_rate = cwrapper.prototype("bool smspec_node_is_rate( smspec_node )") -cfunc.node_unit = cwrapper.prototype("char* smspec_node_get_unit( smspec_node )") -cfunc.node_wgname = cwrapper.prototype("char* smspec_node_get_wgname( smspec_node )") -cfunc.node_keyword = cwrapper.prototype("char* smspec_node_get_keyword( smspec_node )") -cfunc.node_num = cwrapper.prototype("int smspec_node_get_num( smspec_node )") -cfunc.node_need_num = cwrapper.prototype("bool smspec_node_need_nums( smspec_node )") diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_node.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_node.py new file mode 100644 index 0000000000..eb2f4ee1b0 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_node.py @@ -0,0 +1,27 @@ +class EclSumNode: + def __init__(self, mini_step, report_step, days, date, mpl_date, value): + """ + EclSumNode is a 'struct' with a summary value and time. + + EclSumNode - a small 'struct' with a summary value and time in + several formats. When iterating over a EclSumVector instance + you will get EclSumNode instances. The content of the + EclSumNode type is stored as plain attributes: + + value : The actual value + report_step : The report step + mini_step : The ministep + days : Days since simulation start + date : The simulation date + mpl_date : A date format suitable for matplotlib + + """ + self.value = value + self.report_step = report_step + self.mini_step = mini_step + self.days = days + self.date = date + self.mpl_date = mpl_date + + def __str__(self): + return "" % ( self.days, self.value ) \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_vector.py b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_vector.py new file mode 100644 index 0000000000..6dd570b9b3 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/ecl/ecl_sum_vector.py @@ -0,0 +1,281 @@ +from ert.ecl.ecl_sum_node import EclSumNode + + +class EclSumVector: + def __init__(self, parent, key, report_only): + """ + A summary vector with a vector of values and time. + + A summary vector contains the the full time history of one + key, along with the corresponding time vectors in several + different time formats. Depending on the report_only argument + the data vectors in the EclSumVector can either contain all + the time values, or only those corresponding to report_steps. + + The EclSumVector contains a reference to the parent EclSum + structure and this is used to implement several of the + properties and methods of the object; the EclSum vector + instances should therefor only be instantiated through the + EclSum.get_vector() method, and not manually with the + EclSumVector() constructor. + """ + self.parent = parent + self.key = key + self.report_only = report_only + + self.__dates = parent.get_dates(report_only) + self.__days = parent.get_days(report_only) + self.__mpl_dates = parent.get_mpl_dates(report_only) + self.__mini_step = parent.get_mini_step(report_only) + self.__report_step = parent.get_report_step(report_only) + self.__values = None + + + def __str__(self): + return "" % self.key + + + @property + def unit( self ): + """ + The unit of this vector. + """ + return self.parent.get_unit(self.key) + + def assert_values( self ): + """ + This function will load and internalize all the values. + """ + if self.__values is None: + self.__values = self.parent.get_values(self.key, self.report_only) + + @property + def values( self ): + """ + All the summary values of the vector, as a numpy vector. + """ + self.assert_values() + return self.__values + + @property + def dates( self ): + """ + All the dates of the vector, list of datetime() instances. + """ + return self.__dates + + @property + def days( self ): + """ + The time in days as a numpy vector. + + In the case of lab unit this will be hours. + """ + return self.__days + + @property + def mpl_dates( self ): + """ + All the dates as numpy vector of dates in matplotlib format. + """ + return self.__mpl_dates + + @property + def mini_step( self ): + """ + All the ministeps of the vector. + + Ministeps is the ECLIPSE notion of timesteps. The ministeps + are numbered sequentially starting at zero; if you have loaded + the entire simulation the ministep number will correspond to + the natural indexing. The length of each ministep is + determined by the convergence properties of the ECLIPSE + simulation. + """ + return self.__mini_step + + @property + def report_step( self ): + """ + All the report_step of the vector. + """ + return self.__report_step + + + def __iget__( self, index ): + """ + Will return an EclSumNode for element @index; should be called + through the [] operator, otherwise you can come across + unitialized data. + """ + return EclSumNode(self.__mini_step[index], + self.__report_step[index], + self.__days[index], + self.__dates[index], + self.__mpl_dates[index], + self.__values[index]) + + + def __len__(self): + """ + The length of the vector - used for the len() builtin. + """ + return len(self.__days) + + + def __getitem__(self, index): + """ + Implements the [] operator. + + Will return EclSumNode instance according to @index. The index + value will be interpreted as in a normal python [] lookup, + i.e. negative values will be interpreted as starting from the + right and also slice notation is allowed[*]. + + [*] Observe that in the case of slices the return value will + not be a proper EclSumVector instance, but rather a normal + Python list of EclSumNode instances. + """ + self.assert_values() + length = len(self.values) + if isinstance(index, int): + if index < 0: + index += len(self.__values) + if index < 0 or index > length: + raise KeyError("Invalid index:%d out of range [0:%d)" % ( index, length)) + else: + return self.__iget__(index) + elif isinstance(index, slice): + # Observe that the slice based lookup does __not__ return + # a proper EclSumVector instance; it will merely return + # a simple Python list with EclSumNode instances. + (start, stop, step) = index.indices(length) + index = start + sub_vector = [] + while index < stop: + sub_vector.append(self.__iget__(index)) + index += step + return sub_vector + + raise KeyError("Invalid index:%s - must have integer or slice." % index) + + @property + def first( self ): + """ + Will return the first EclSumNode in this vector. + """ + self.assert_values() + return self.__iget__(0) + + @property + def last( self ): + """ + Will return the last EclSumNode in this vector. + """ + self.assert_values() + + index = len(self.__values) - 1 + return self.__iget__(index) + + @property + def last_value( self ): + """ + Will return the last value in this vector. + """ + self.assert_values() + + index = len(self.__values) - 1 + return self.__iget__(index).value + + + def get_interp( self, days=None, date=None): + """ + Will lookup value interpolated to @days or @date. + + The function requires one, and only one, time indicator in + terms of @days or @date. If the @date variable is given that + should be Python datetime instance. + + vec = sum["WWCT:A-3"] + vec.get_interp( days = 100 ) + vec.get_interp( date = datetime.date( year , month , day )) + + This function will crash and burn if the time arguments are + invalid; if in doubt you should check first. + """ + return self.parent.get_interp(self.key, days, date) + + + def get_interp_vector( self, days_list=None, date_list=None): + """ + Will return Python list of interpolated values. + + See get_interp() for further details. + """ + return self.parent.get_interp_vector(self.key, days_list, date_list) + + + def get_from_report( self, report_step ): + """ + Will lookup the value based on @report_step. + """ + return self.parent.get_from_report(self.key, report_step) + + ################################################################# + + def first_gt_index( self, limit ): + """ + Locates first index where the value is above @limit. + + Observe that this method will raise an exception if it is + called from a vector instance with report_only = True. + """ + if not self.report_only: + key_index = self.parent.cNamespace().get_general_var_index(self.parent, self.key) + time_index = self.parent.cNamespace().get_first_gt(self.parent, key_index, limit) + return time_index + else: + raise Exception("Sorry - first_gt_index() can not be called for vectors with report_only=True") + + def first_gt( self, limit ): + """ + Locate the first EclSumNode where value is above @limit. + + vec = sum["WWCT:A-3"] + w = vec.first_gt( 0.50 ) + print "Water cut above 0.50 in well A-3 at: %s" % w.date + + Uses first_gt_index() internally and can not be called for + vectors with report_only = True. + """ + time_index = self.first_gt_index(limit) + print time_index + if time_index >= 0: + return self.__iget__(time_index) + else: + return None + + def first_lt_index( self, limit ): + """ + Locates first index where the value is below @limit. + + See first_gt_index() for further details. + """ + if not self.report_only: + key_index = self.parent.cNamespace().get_general_var_index(self.parent, self.key) + time_index = self.parent.cNamespace().get_first_lt(self.parent, key_index, limit) + return time_index + else: + raise Exception("Sorry - first_lt_index() can not be called for vectors with report_only=True") + + def first_lt( self, limit ): + """ + Locates first element where the value is below @limit. + + See first_gt() for further details. + """ + time_index = self.first_lt_index(limit) + if time_index >= 0: + return self.__iget__(time_index) + else: + return None diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/enkf/CMakeLists.txt index 5969d2c5ee..6b1c01ce7e 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/CMakeLists.txt @@ -1,30 +1,25 @@ +add_subdirectory( data ) +add_subdirectory( util ) + set(PYTHON_SOURCES __init__.py analysis_config.py - enkf_main.py - ert_templates.py - gen_kw_config.py - model_config.py - ecl_config.py - enkf_node.py - field_config.py - obs_vector.py - enkf_config_node.py - enkf_obs.py block_obs.py - libenkf.py - plot_conf.py + ecl_config.py enkf_enum.py - enkf.py - field.py - local_config.py - site_config.py enkf_fs.py - ens_config.py - gen_data_config.py - time_map.py - ert_template.py + enkf_main.py + enkf_obs.py enkf_state.py + ens_config.py + ert_template.py + ert_templates.py + local_config.py + model_config.py + plot_config.py + site_config.py ) add_python_package("Python ert.enkf" ${PYTHON_INSTALL_PREFIX}/ert/enkf "${PYTHON_SOURCES}" True) + + diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/__init__.py b/ThirdParty/Ert/devel/python/python/ert/enkf/__init__.py index 79c95cf38a..058d16293b 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/__init__.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/__init__.py @@ -15,3 +15,28 @@ # for more details. +import ert.cwrap.clib as clib + +clib.ert_load("libanalysis.so") +ENKF_LIB = clib.ert_load("libenkf.so") + +from ert.enkf.util import ObsVector, TimeMap + +from .enkf_enum import EnkfStateEnum, EnkfRunEnum + +from .analysis_config import AnalysisConfig +from .block_obs import BlockObs +from .ecl_config import EclConfig +from .enkf_fs import EnkfFs +from .enkf_obs import EnkfObs +from .enkf_state import EnKFState +from .ens_config import EnsConfig +from .ert_template import ErtTemplate +from .ert_templates import ErtTemplates +from .local_config import LocalConfig +from .model_config import ModelConfig +from .plot_config import PlotConfig +from .site_config import SiteConfig + +from ert.enkf.data import EnkfConfigNode, EnkfNode, GenDataConfig, GenKwConfig, FieldConfig, Field + diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/analysis_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/analysis_config.py index 6325c4c21d..e56e0fc5e2 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/analysis_config.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/analysis_config.py @@ -12,74 +12,65 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -class AnalysisConfig(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property +class AnalysisConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + def get_rerun(self): - return cfunc.get_rerun( self ) + return AnalysisConfig.cNamespace().get_rerun(self) def set_rerun(self, rerun): - cfunc.set_rerun(self, rerun) - - @property + AnalysisConfig.cNamespace().set_rerun(self, rerun) + def get_rerun_start(self): - return cfunc.get_rerun_start( self ) + return AnalysisConfig.cNamespace().get_rerun_start(self) - def set_rerun_start(self, int): - cfunc.set_rerun_start( self , int) + def set_rerun_start(self, index): + AnalysisConfig.cNamespace().set_rerun_start(self, index) - @property def get_log_path(self): - return cfunc.get_log_path( self ) + return AnalysisConfig.cNamespace().get_log_path(self) def set_log_path(self, path): - cfunc.set_log_path( self, path) + AnalysisConfig.cNamespace().set_log_path(self, path) - @property def get_alpha(self): - return cfunc.get_alpha( self ) + return AnalysisConfig.cNamespace().get_alpha(self) def set_alpha(self, alpha): - cfunc.set_alpha( self , alpha) + AnalysisConfig.cNamespace().set_alpha(self, alpha) - @property def get_merge_observations(self): - return cfunc.get_merge_observations( self ) - + return AnalysisConfig.cNamespace().get_merge_observations(self) + def set_merge_observations(self, merge_observations): - return cfunc.set_merge_observations( self , merge_observations) -################################################################## + return AnalysisConfig.cNamespace().set_merge_observations(self, merge_observations) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "analysis_config" , AnalysisConfig ) + def free(self): + AnalysisConfig.cNamespace().free(self) -cfunc = CWrapperNameSpace("analysis_config") + ################################################################## + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("analysis_config", AnalysisConfig) +cwrapper.registerType("analysis_config_obj", AnalysisConfig.createPythonObject) +cwrapper.registerType("analysis_config_ref", AnalysisConfig.createCReference) -cfunc.free = cwrapper.prototype("void analysis_config_free( analysis_config )") -cfunc.get_rerun = cwrapper.prototype("int analysis_config_get_rerun( analysis_config )") -cfunc.set_rerun = cwrapper.prototype("void analysis_config_set_rerun( analysis_config, bool)") -cfunc.get_rerun_start = cwrapper.prototype("int analysis_config_get_rerun_start( analysis_config )") -cfunc.set_rerun_start = cwrapper.prototype("void analysis_config_set_rerun_start( analysis_config, int)") -cfunc.get_log_path = cwrapper.prototype("char* analysis_config_get_log_path( analysis_config)") -cfunc.set_log_path = cwrapper.prototype("void analysis_config_set_log_path( analysis_config, char*)") -cfunc.get_alpha = cwrapper.prototype("double analysis_config_get_alpha(analysis_config)") -cfunc.set_alpha = cwrapper.prototype("void analysis_config_set_alpha(analysis_config, double)") -cfunc.get_merge_observations = cwrapper.prototype("bool analysis_config_get_merge_observations(analysis_config)") -cfunc.set_merge_observations = cwrapper.prototype("void analysis_config_set_merge_observations(analysis_config, bool)") +AnalysisConfig.cNamespace().free = cwrapper.prototype("void analysis_config_free( analysis_config )") +AnalysisConfig.cNamespace().get_rerun = cwrapper.prototype("int analysis_config_get_rerun( analysis_config )") +AnalysisConfig.cNamespace().set_rerun = cwrapper.prototype("void analysis_config_set_rerun( analysis_config, bool)") +AnalysisConfig.cNamespace().get_rerun_start = cwrapper.prototype("int analysis_config_get_rerun_start( analysis_config )") +AnalysisConfig.cNamespace().set_rerun_start = cwrapper.prototype("void analysis_config_set_rerun_start( analysis_config, int)") +AnalysisConfig.cNamespace().get_log_path = cwrapper.prototype("char* analysis_config_get_log_path( analysis_config)") +AnalysisConfig.cNamespace().set_log_path = cwrapper.prototype("void analysis_config_set_log_path( analysis_config, char*)") +AnalysisConfig.cNamespace().get_alpha = cwrapper.prototype("double analysis_config_get_alpha(analysis_config)") +AnalysisConfig.cNamespace().set_alpha = cwrapper.prototype("void analysis_config_set_alpha(analysis_config, double)") +AnalysisConfig.cNamespace().get_merge_observations = cwrapper.prototype("bool analysis_config_get_merge_observations(analysis_config)") +AnalysisConfig.cNamespace().set_merge_observations = cwrapper.prototype("void analysis_config_set_merge_observations(analysis_config, bool)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/block_obs.py b/ThirdParty/Ert/devel/python/python/ert/enkf/block_obs.py index af15b20f8c..f7eccd3067 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/block_obs.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/block_obs.py @@ -12,47 +12,43 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -class BlockObs(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - def iget_i(self , index): - return cfunc.iget_i( self ,index ) +class BlockObs(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - def iget_j(self , index): - return cfunc.iget_j( self ,index ) + def iget_i(self, index): + return BlockObs.cNamespace().iget_i(self, index) - def iget_k(self , index): - return cfunc.iget_k( self ,index ) + def iget_j(self, index): + return BlockObs.cNamespace().iget_j(self, index) + + def iget_k(self, index): + return BlockObs.cNamespace().iget_k(self, index) def get_size(self): - return cfunc.get_size(self) + return BlockObs.cNamespace().get_size(self) def iget(self, index, value, std): - return cfunc.iget(self, index, value, std) + return BlockObs.cNamespace().iget(self, index, value, std) + + def free(self): + BlockObs.cNamespace().free(self) ################################################################## -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "block_obs" , BlockObs ) -cfunc = CWrapperNameSpace("block_obs") +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("block_obs", BlockObs) +cwrapper.registerType("block_obs_obj", BlockObs.createPythonObject) +cwrapper.registerType("block_obs_ref", BlockObs.createCReference) - -cfunc.free = cwrapper.prototype("void block_obs_free( block_obs )") -cfunc.iget_i = cwrapper.prototype("int block_obs_iget_i(block_obs, int)") -cfunc.iget_j = cwrapper.prototype("int block_obs_iget_j( block_obs, int)") -cfunc.iget_k = cwrapper.prototype("int block_obs_iget_k( block_obs , int)") -cfunc.get_size = cwrapper.prototype("int block_obs_get_size( block_obs )") -cfunc.iget = cwrapper.prototype("void block_obs_iget( block_obs, int, double*, double*)") +BlockObs.cNamespace().free = cwrapper.prototype("void block_obs_free( block_obs )") +BlockObs.cNamespace().iget_i = cwrapper.prototype("int block_obs_iget_i(block_obs, int)") +BlockObs.cNamespace().iget_j = cwrapper.prototype("int block_obs_iget_j( block_obs, int)") +BlockObs.cNamespace().iget_k = cwrapper.prototype("int block_obs_iget_k( block_obs , int)") +BlockObs.cNamespace().get_size = cwrapper.prototype("int block_obs_get_size( block_obs )") +BlockObs.cNamespace().iget = cwrapper.prototype("void block_obs_iget( block_obs, int, double*, double*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/enkf/data/CMakeLists.txt new file mode 100644 index 0000000000..781e9765cf --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/CMakeLists.txt @@ -0,0 +1,12 @@ +set(PYTHON_SOURCES + __init__.py + enkf_config_node.py + enkf_node.py + gen_data_config.py + gen_kw_config.py + field.py + field_config.py + summary_config.py +) + +add_python_package("Python ert.enkf.data" ${PYTHON_INSTALL_PREFIX}/ert/enkf/data "${PYTHON_SOURCES}" True) \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/__init__.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/__init__.py new file mode 100644 index 0000000000..f65a6bba21 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/__init__.py @@ -0,0 +1,10 @@ +import ert.enkf + +from .gen_data_config import GenDataConfig +from .gen_kw_config import GenKwConfig +from .field_config import FieldConfig +from .summary_config import SummaryConfig +from .enkf_node import EnkfNode + +from .enkf_config_node import EnkfConfigNode +from .field import Field diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_config_node.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_config_node.py new file mode 100644 index 0000000000..597ccf15bf --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_config_node.py @@ -0,0 +1,95 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'enkf_config_node.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB +from ert.enkf.data import FieldConfig, GenDataConfig, GenKwConfig, EnkfNode, SummaryConfig + + +class EnkfConfigNode(BaseCClass): + FIELD = 104 + GEN_KW = 107 + SUMMARY = 110 + GEN_DATA = 113 + + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def getImplementationType( self ): + return EnkfConfigNode.cNamespace().get_impl_type(self) + + def get_var_type( self ): + return EnkfConfigNode.cNamespace().get_var_type(self) + + def getPointerReference(self): + return EnkfConfigNode.cNamespace().get_ref(self) + + def get_min_std_file(self): + return EnkfConfigNode.cNamespace().get_min_std_file(self) + + def get_enkf_outfile(self): + return EnkfConfigNode.cNamespace().get_enkf_outfile(self) + + def getFieldModelConfig(self): + return FieldConfig.createCReference(EnkfConfigNode.cNamespace().get_ref(self), parent=self) + + def getDataModelConfig(self): + return GenDataConfig.createCReference(EnkfConfigNode.cNamespace().get_ref(self), parent=self) + + def getKeywordModelConfig(self): + return GenKwConfig.createCReference(EnkfConfigNode.cNamespace().get_ref(self), parent=self) + + def get_enkf_infile(self): + return EnkfConfigNode.cNamespace().get_enkf_infile(self) + + def alloc_node(self): + return EnkfNode(self) + + def get_init_file_fmt(self): + return EnkfConfigNode.cNamespace().get_init_file_fmt(self) + + def free(self): + EnkfConfigNode.cNamespace().free(self) + + def getModelConfig(self): + implementation_type = self.getImplementationType() + + if implementation_type == self.FIELD: + return self.getFieldModelConfig() + elif implementation_type == self.GEN_DATA: + return self.getDataModelConfig() + elif implementation_type == self.GEN_KW: + return self.getKeywordModelConfig() + elif implementation_type == self.SUMMARY: + return SummaryConfig.createCReference(self.getPointerReference(), parent=self) + else: + print("[EnkfConfigNode::getModelConfig()] Unhandled implementation model type: %i" % implementation_type) + # raise NotImplementedError("Unknown model type: %i" % type) + + + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("enkf_config_node", EnkfConfigNode) +cwrapper.registerType("enkf_config_node_obj", EnkfConfigNode.createPythonObject) +cwrapper.registerType("enkf_config_node_ref", EnkfConfigNode.createCReference) + +EnkfConfigNode.cNamespace().free = cwrapper.prototype("void enkf_config_node_free( enkf_config_node )") +EnkfConfigNode.cNamespace().get_ref = cwrapper.prototype("c_void_p enkf_config_node_get_ref(enkf_config_node)") #todo: fix return type +EnkfConfigNode.cNamespace().get_impl_type = cwrapper.prototype("int enkf_config_node_get_impl_type(enkf_config_node)") #todo: fix return type as enum +EnkfConfigNode.cNamespace().get_enkf_outfile = cwrapper.prototype("char* enkf_config_node_get_enkf_outfile(enkf_config_node)") +EnkfConfigNode.cNamespace().get_min_std_file = cwrapper.prototype("char* enkf_config_node_get_min_std_file(enkf_config_node)") +EnkfConfigNode.cNamespace().get_enkf_infile = cwrapper.prototype("char* enkf_config_node_get_enkf_infile(enkf_config_node)") +EnkfConfigNode.cNamespace().get_init_file_fmt = cwrapper.prototype("char* enkf_config_node_get_init_file_fmt(enkf_config_node)") +EnkfConfigNode.cNamespace().get_var_type = cwrapper.prototype("c_void_p enkf_config_node_get_var_type(enkf_config_node)") #todo: fix return type as enum diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_node.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_node.py new file mode 100644 index 0000000000..ded77f78b0 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/enkf_node.py @@ -0,0 +1,58 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'enkf_node.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB +import ert + + +class EnkfNode(BaseCClass): + def __init__(self, config_node): + assert isinstance(config_node, ert.enkf.data.EnkfConfigNode) + + c_pointer = EnkfNode.cNamespace().alloc(config_node) + super(EnkfNode, self).__init__(c_pointer, config_node, True) + + def user_get(self, fs, key, report_step, iens, state, value): + return EnkfNode.cNamespace().user_get(self, fs, key, report_step, iens, state, value) + + def user_get_vector( self, fs, key, iens, state, vector): + return EnkfNode.cNamespace().user_get_vector(self, fs, key, iens, state, vector) + + def value_ptr(self): + EnkfNode.cNamespace().value_ptr(self) + + def vector_storage(self): + return EnkfNode.cNamespace().vector_storage(self) + + def free(self): + EnkfNode.cNamespace().free(self) + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("enkf_node", EnkfNode) +cwrapper.registerType("enkf_node_obj", EnkfNode.createPythonObject) +cwrapper.registerType("enkf_node_ref", EnkfNode.createCReference) + +# 3. Installing the c-functions used to manipulate ecl_kw instances. +# These functions are used when implementing the EclKW class, not +# used outside this scope. + + +EnkfNode.cNamespace().free = cwrapper.prototype("void enkf_node_free( enkf_node )") +EnkfNode.cNamespace().alloc = cwrapper.prototype("c_void_p enkf_node_alloc( enkf_node)") +EnkfNode.cNamespace().user_get = cwrapper.prototype("bool enkf_node_user_get_no_id(enkf_node , enkf_fs , char* , int, int , c_uint, double*)") +EnkfNode.cNamespace().user_get_vector = cwrapper.prototype("bool enkf_node_user_get_vector( enkf_node , enkf_fs , char*, int, c_uint, double_vector)") +EnkfNode.cNamespace().value_ptr = cwrapper.prototype("void enkf_node_value_ptr(enkf_node)") +EnkfNode.cNamespace().vector_storage = cwrapper.prototype("bool enkf_node_vector_storage(enkf_node)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/field.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/field.py new file mode 100644 index 0000000000..508304e2f9 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/field.py @@ -0,0 +1,39 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'field.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB + + +class Field(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def ijk_get_double(self, i, j, k): + return Field.cNamespace().ijk_get_double(self, i, j, k) + + def free(self): + Field.cNamespace().free(self) + + +################################################################## + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("field", Field) +cwrapper.registerType("field_obj", Field.createPythonObject) +cwrapper.registerType("field_ref", Field.createCReference) + +Field.cNamespace().free = cwrapper.prototype("void field_free( field )") +Field.cNamespace().ijk_get_double = cwrapper.prototype("double field_ijk_get_double(field, int, int, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/field_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/field_config.py new file mode 100644 index 0000000000..3af37b1697 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/field_config.py @@ -0,0 +1,74 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'field_config.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB + + +class FieldConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def get_type(self): + return FieldConfig.cNamespace().get_type(self) + + def get_truncation_mode(self): + return FieldConfig.cNamespace().get_truncation_mode(self) + + def get_truncation_min(self): + return FieldConfig.cNamespace().get_truncation_min(self) + + def get_init_transform_name(self): + return FieldConfig.cNamespace().get_init_transform_name(self) + + def get_output_transform_name(self): + return FieldConfig.cNamespace().get_output_transform_name(self) + + def get_truncation_max(self): + return FieldConfig.cNamespace().get_truncation_max(self) + + def get_nx(self): + return FieldConfig.cNamespace().get_nx(self) + + def get_ny(self): + return FieldConfig.cNamespace().get_ny(self) + + def get_nz(self): + return FieldConfig.cNamespace().get_nz(self) + + def ijk_active(self, i, j, k): + return FieldConfig.cNamespace().ijk_active(self, i, j, k) + + def free(self): + FieldConfig.cNamespace().free(self) + + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("field_config", FieldConfig) +cwrapper.registerType("field_config_obj", FieldConfig.createPythonObject) +cwrapper.registerType("field_config_ref", FieldConfig.createCReference) + +FieldConfig.cNamespace().free = cwrapper.prototype("void field_config_free( field_config )") +FieldConfig.cNamespace().get_type = cwrapper.prototype("int field_config_get_type(field_config)") +FieldConfig.cNamespace().get_truncation_mode = cwrapper.prototype("int field_config_get_truncation_mode(field_config)") +FieldConfig.cNamespace().get_truncation_min = cwrapper.prototype("double field_config_get_truncation_min(field_config)") +FieldConfig.cNamespace().get_truncation_max = cwrapper.prototype("double field_config_get_truncation_max(field_config)") +FieldConfig.cNamespace().get_init_transform_name = cwrapper.prototype("char* field_config_get_init_transform_name(field_config)") +FieldConfig.cNamespace().get_output_transform_name = cwrapper.prototype("char* field_config_get_output_transform_name(field_config)") +FieldConfig.cNamespace().ijk_active = cwrapper.prototype("bool field_config_ijk_active(field_config, int, int, int)") +FieldConfig.cNamespace().get_nx = cwrapper.prototype("int field_config_get_nx(field_config)") +FieldConfig.cNamespace().get_ny = cwrapper.prototype("int field_config_get_ny(field_config)") +FieldConfig.cNamespace().get_nz = cwrapper.prototype("int field_config_get_nz(field_config)") +FieldConfig.cNamespace().get_grid = cwrapper.prototype("c_void_p field_config_get_grid(field_config)") #todo: fix return type diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_data_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_data_config.py new file mode 100644 index 0000000000..769e04b68d --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_data_config.py @@ -0,0 +1,58 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'gen_data_config.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB + + +class GenDataConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def get_template_file(self): + return GenDataConfig.cNamespace().get_template_file(self) + + def get_template_key(self): + return GenDataConfig.cNamespace().get_template_key(self) + + def get_initial_size(self): + return GenDataConfig.cNamespace().get_initial_size(self) + + def get_output_format(self): + return GenDataConfig.cNamespace().get_output_format(self) + + def get_input_format(self): + return GenDataConfig.cNamespace().get_input_format(self) + + def free(self): + GenDataConfig.cNamespace().free(self) + + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("gen_data_config", GenDataConfig) +cwrapper.registerType("gen_data_config_obj", GenDataConfig.createPythonObject) +cwrapper.registerType("gen_data_config_ref", GenDataConfig.createCReference) + +# 3. Installing the c-functions used to manipulate ecl_kw instances. +# These functions are used when implementing the EclKW class, not +# used outside this scope. + +GenDataConfig.cNamespace().free = cwrapper.prototype("void gen_data_config_free( gen_data_config )") +GenDataConfig.cNamespace().get_output_format = cwrapper.prototype("c_void_p gen_data_config_get_output_format(gen_data_config)") #todo: fix return type +GenDataConfig.cNamespace().get_input_format = cwrapper.prototype("c_void_p gen_data_config_get_input_format(gen_data_config)") #todo: fix return type +GenDataConfig.cNamespace().get_template_file = cwrapper.prototype("char* gen_data_config_get_template_file(gen_data_config)") +GenDataConfig.cNamespace().get_template_key = cwrapper.prototype("char* gen_data_config_get_template_key(gen_data_config)") +GenDataConfig.cNamespace().get_initial_size = cwrapper.prototype("int gen_data_config_get_initial_size(gen_data_config)") + diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_kw_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_kw_config.py new file mode 100644 index 0000000000..10d885f859 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/gen_kw_config.py @@ -0,0 +1,47 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'gen_kw_config.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB +from ert.util import StringList + + +class GenKwConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def get_template_file(self): + return GenKwConfig.cNamespace().get_template_file(self) + + def get_parameter_file(self): + return GenKwConfig.cNamespace().get_parameter_file(self) + + def alloc_name_list(self): + return GenKwConfig.cNamespace().alloc_name_list(self).setParent(self) + + def free(self): + GenKwConfig.cNamespace().free(self) + +################################################################## + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("gen_kw_config", GenKwConfig) +cwrapper.registerType("gen_kw_config_obj", GenKwConfig.createPythonObject) +cwrapper.registerType("gen_kw_config_ref", GenKwConfig.createCReference) + +GenKwConfig.cNamespace().free = cwrapper.prototype("void gen_kw_config_free( gen_kw_config )") +GenKwConfig.cNamespace().get_template_file = cwrapper.prototype("char* gen_kw_config_get_template_file(gen_kw_config)") +GenKwConfig.cNamespace().get_parameter_file = cwrapper.prototype("char* gen_kw_config_get_parameter_file(gen_kw_config)") +GenKwConfig.cNamespace().alloc_name_list = cwrapper.prototype("stringlist_ref gen_kw_config_alloc_name_list(gen_kw_config)") diff --git a/ThirdParty/Ert/devel/python/python/ert/config/config_enums.py b/ThirdParty/Ert/devel/python/python/ert/enkf/data/summary_config.py similarity index 51% rename from ThirdParty/Ert/devel/python/python/ert/config/config_enums.py rename to ThirdParty/Ert/devel/python/python/ert/enkf/data/summary_config.py index 22279e6fa2..2239f3bd65 100644 --- a/ThirdParty/Ert/devel/python/python/ert/config/config_enums.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/data/summary_config.py @@ -1,6 +1,6 @@ -# Copyright (C) 2013 Statoil ASA, Norway. +# Copyright (C) 2012 Statoil ASA, Norway. # -# The file 'config_enums.py' is part of ERT - Ensemble based Reservoir Tool. +# The file 'field_config.py' is part of ERT - Ensemble based Reservoir Tool. # # ERT is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -13,10 +13,17 @@ # # See the GNU General Public License at # for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB -from ert.cwrap import create_enum -from ert.config import CONFIG_LIB -ContentTypeEnum = create_enum(CONFIG_LIB, "config_schema_item_type_enum_iget", "ContentTypeEnum") +class SummaryConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("summary_config", SummaryConfig) +cwrapper.registerType("summary_config", SummaryConfig.createPythonObject) +cwrapper.registerType("summary_config", SummaryConfig.createCReference) -UnrecognizedEnum = create_enum(CONFIG_LIB, "config_schema_item_unrecognized_enum_iget", "UnrecognizedEnum") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/ecl_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/ecl_config.py index afe2c50419..47b6bafbd2 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/ecl_config.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/ecl_config.py @@ -12,110 +12,93 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. - -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -import libenkf -from ert.ecl.ecl_sum import EclSum -from ert.util.stringlist import StringList +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB +from ert.util import StringList +from ert.ecl import EclSum -class EclConfig(CClass): - def __init__(self, c_ptr, parent=None): - if parent: - self.init_cref(c_ptr, parent) - else: - self.init_cobj(c_ptr, cfunc.free) +class EclConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - @property def get_eclbase(self): - eclbase = cfunc.get_eclbase(self) - return eclbase + return EclConfig.cNamespace().get_eclbase(self) - @property def get_data_file(self): - datafile = cfunc.get_data_file(self) - return datafile + return EclConfig.cNamespace().get_data_file(self) - @property def get_gridfile(self): - gridfile = cfunc.get_gridfile(self) - return gridfile + """ @rtype: str """ + return EclConfig.cNamespace().get_gridfile(self) def set_gridfile(self, gridfile): - cfunc.set_gridfile(self, gridfile) + EclConfig.cNamespace().set_gridfile(self, gridfile) - @property def get_schedule_file(self): - schedule_file = cfunc.get_schedule_file(self) - return schedule_file + return EclConfig.cNamespace().get_schedule_file(self) def set_schedule_file(self, schedule_file): - schedule_file = cfunc.set_schedule_file(self, schedule_file) + EclConfig.cNamespace().set_schedule_file(self, schedule_file) - @property def get_init_section(self): - init_section = cfunc.get_init_section(self) - return init_section + return EclConfig.cNamespace().get_init_section(self) def set_init_section(self, init_section): - cfunc.set_init_section(self, init_section) + EclConfig.cNamespace().set_init_section(self, init_section) - @property def get_refcase_name(self): - refcase_name = cfunc.get_refcase_name(self) - return refcase_name + return EclConfig.cNamespace().get_refcase_name(self) def load_refcase(self, refcase): - cfunc.load_refcase(self, refcase) + EclConfig.cNamespace().load_refcase(self, refcase) - @property def get_static_kw_list(self): - return StringList(c_ptr=cfunc.get_static_kw_list(self), parent=self) + """ @rtype: StringList """ + return EclConfig.cNamespace().get_static_kw_list(self).setParent(self) - @property def get_refcase(self): - refcase = EclSum(self.get_refcase_name, join_string=":", include_restart=True, c_ptr=cfunc.get_refcase(self), - parent=self) - return refcase + """ @rtype: EclSum """ + return EclConfig.cNamespace().get_refcase(self).setParent(self) def clear_static_kw(self): - cfunc.clear_static_kw(self) + EclConfig.cNamespace().clear_static_kw(self) def add_static_kw(self, kw): - cfunc.add_static_kw(self, kw) + EclConfig.cNamespace().add_static_kw(self, kw) - @property def get_grid(self): - return cfunc.get_grid(self) + return EclConfig.cNamespace().get_grid(self) - @property def get_sched_file(self): - return cfunc.get_sched_file(self) + return EclConfig.cNamespace().get_sched_file(self) - ################################################################## + def free(self): + EclConfig.cNamespace().free(self) -cwrapper = CWrapper(libenkf.lib) + +cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ecl_config", EclConfig) +cwrapper.registerType("ecl_config_obj", EclConfig.createPythonObject) +cwrapper.registerType("ecl_config_ref", EclConfig.createCReference) -cfunc = CWrapperNameSpace("ecl_config") -cfunc.free = cwrapper.prototype("void ecl_config_free( ecl_config )") -cfunc.get_eclbase = cwrapper.prototype("char* ecl_config_get_eclbase( ecl_config )") -cfunc.get_data_file = cwrapper.prototype("char* ecl_config_get_data_file(ecl_config)") -cfunc.get_gridfile = cwrapper.prototype("char* ecl_config_get_gridfile(ecl_config)") -cfunc.set_gridfile = cwrapper.prototype("void ecl_config_set_grid(ecl_config, char*)") -cfunc.get_schedule_file = cwrapper.prototype("char* ecl_config_get_schedule_file(ecl_config)") -cfunc.set_schedule_file = cwrapper.prototype("void ecl_config_set_schedule_file(ecl_config, char*)") -cfunc.get_init_section = cwrapper.prototype("char* ecl_config_get_init_section(ecl_config)") -cfunc.set_init_section = cwrapper.prototype("void ecl_config_set_init_section(ecl_config, char*)") -cfunc.get_refcase_name = cwrapper.prototype("char* ecl_config_get_refcase_name(ecl_config)") -cfunc.load_refcase = cwrapper.prototype("void ecl_config_load_refcase(ecl_config, char*)") -cfunc.get_static_kw_list = cwrapper.prototype("c_void_p ecl_config_get_static_kw_list(ecl_config)") -cfunc.clear_static_kw = cwrapper.prototype("void ecl_config_clear_static_kw(ecl_config)") -cfunc.add_static_kw = cwrapper.prototype("void ecl_config_add_static_kw(ecl_config, char*)") -cfunc.get_grid = cwrapper.prototype("c_void_p ecl_config_get_grid(ecl_config)") -cfunc.get_refcase = cwrapper.prototype("c_void_p ecl_config_get_refcase(ecl_config)") -cfunc.get_sched_file = cwrapper.prototype("c_void_p ecl_config_get_sched_file(ecl_config)") +EclConfig.cNamespace().free = cwrapper.prototype("void ecl_config_free( ecl_config )") +EclConfig.cNamespace().get_eclbase = cwrapper.prototype("char* ecl_config_get_eclbase( ecl_config )") +EclConfig.cNamespace().get_data_file = cwrapper.prototype("char* ecl_config_get_data_file(ecl_config)") +EclConfig.cNamespace().get_gridfile = cwrapper.prototype("char* ecl_config_get_gridfile(ecl_config)") +EclConfig.cNamespace().set_gridfile = cwrapper.prototype("void ecl_config_set_grid(ecl_config, char*)") +EclConfig.cNamespace().get_schedule_file = cwrapper.prototype("char* ecl_config_get_schedule_file(ecl_config)") +EclConfig.cNamespace().set_schedule_file = cwrapper.prototype("void ecl_config_set_schedule_file(ecl_config, char*)") +EclConfig.cNamespace().get_init_section = cwrapper.prototype("char* ecl_config_get_init_section(ecl_config)") +EclConfig.cNamespace().set_init_section = cwrapper.prototype("void ecl_config_set_init_section(ecl_config, char*)") +EclConfig.cNamespace().get_refcase_name = cwrapper.prototype("char* ecl_config_get_refcase_name(ecl_config)") +EclConfig.cNamespace().load_refcase = cwrapper.prototype("void ecl_config_load_refcase(ecl_config, char*)") +EclConfig.cNamespace().get_static_kw_list = cwrapper.prototype("stringlist_ref ecl_config_get_static_kw_list(ecl_config)") +EclConfig.cNamespace().clear_static_kw = cwrapper.prototype("void ecl_config_clear_static_kw(ecl_config)") +EclConfig.cNamespace().add_static_kw = cwrapper.prototype("void ecl_config_add_static_kw(ecl_config, char*)") + +EclConfig.cNamespace().get_grid = cwrapper.prototype("c_void_p ecl_config_get_grid(ecl_config)") #todo: fix return type!!! +EclConfig.cNamespace().get_refcase = cwrapper.prototype("ecl_sum_ref ecl_config_get_refcase(ecl_config)") +EclConfig.cNamespace().get_sched_file = cwrapper.prototype("c_void_p ecl_config_get_sched_file(ecl_config)") #todo: fix return type!!! diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf.py deleted file mode 100644 index c664e6287a..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf.py +++ /dev/null @@ -1,3 +0,0 @@ -import libenkf -#from enkf_main import EnKFMain -from enkf_enum import * diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_config_node.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_config_node.py deleted file mode 100644 index a0d07f96b3..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_config_node.py +++ /dev/null @@ -1,95 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'enkf_config_node.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -from ert.enkf.gen_data_config import GenDataConfig -from ert.enkf.gen_kw_config import GenKwConfig -from ert.enkf.field_config import FieldConfig -from ert.enkf.enkf_node import EnkfNode - -class EnkfConfigNode(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_impl_type( self ): - return cfunc.get_impl_type( self ) - - @property - def get_var_type( self ): - return cfunc.get_var_type( self ) - - @property - def get_ref(self): - return cfunc.get_ref( self) - - @property - def get_min_std_file(self): - return cfunc.get_min_std_file( self) - - @property - def get_enkf_outfile(self): - return cfunc.get_enkf_outfile( self) - - @property - def field_model(self): - return FieldConfig(c_ptr = cfunc.get_ref( self), parent = self) - - @property - def data_model(self): - return GenDataConfig(c_ptr = cfunc.get_ref( self), parent = self) - - @property - def keyword_model(self): - return GenKwConfig(c_ptr = cfunc.get_ref( self), parent = self) - - @property - def get_enkf_infile(self): - return cfunc.get_enkf_infile( self) - - @property - def alloc_node(self): - node = EnkfNode.alloc(self) - return node - - @property - def get_init_file_fmt(self): - return cfunc.get_init_file_fmt(self) -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "enkf_config_node" , EnkfConfigNode ) - -cfunc = CWrapperNameSpace("enkf_config_node") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void enkf_config_node_free( enkf_config_node )") -cfunc.get_ref = cwrapper.prototype("c_void_p enkf_config_node_get_ref(enkf_config_node)") -cfunc.get_impl_type = cwrapper.prototype("c_void_p enkf_config_node_get_impl_type(enkf_config_node)") -cfunc.get_enkf_outfile = cwrapper.prototype("char* enkf_config_node_get_enkf_outfile(enkf_config_node)") -cfunc.get_min_std_file = cwrapper.prototype("char* enkf_config_node_get_min_std_file(enkf_config_node)") -cfunc.get_enkf_infile = cwrapper.prototype("char* enkf_config_node_get_enkf_infile(enkf_config_node)") -cfunc.get_init_file_fmt = cwrapper.prototype("char* enkf_config_node_get_init_file_fmt(enkf_config_node)") -cfunc.get_var_type = cwrapper.prototype("c_void_p enkf_config_node_get_var_type(enkf_config_node)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_enum.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_enum.py index d5c3e9d641..a8737d2874 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_enum.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_enum.py @@ -14,11 +14,10 @@ # See the GNU General Public License at # for more details. -from ert.cwrap.cenum import create_enum -import libenkf +from ert.cwrap.cenum import create_enum +from ert.enkf import ENKF_LIB -name_space = globals() -name_space["enkf_state_enum"] = create_enum( libenkf.lib , "enkf_state_enum_iget" , "enkf_state_enum") -name_space["enkf_run_enum"] = create_enum( libenkf.lib , "enkf_run_enum_iget" , "enkf_run_enum") +EnkfStateEnum = create_enum(ENKF_LIB, "enkf_state_enum_iget", "enkf_state_enum") +EnkfRunEnum = create_enum(ENKF_LIB, "enkf_run_enum_iget", "enkf_run_enum") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_fs.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_fs.py index 49bae0d6d1..e84f041def 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_fs.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_fs.py @@ -12,62 +12,52 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB, TimeMap +from ert.util import Buffer -import ctypes -from ctypes import c_buffer -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -from ert.ert.enums import enkf_var_type, ert_state_enum -from ert.enkf.time_map import TimeMap -from ert.util.buffer import Buffer -import libenkf -from ert.ert.c_enums import state_enum -from ert.ert.c_enums import var_type -class EnkfFs(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.close ) + +class EnkfFs(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") def has_node(self, node_key, var_type, report_step, iens, state): - return cfunc.has_node(self, node_key, var_type, report_step, iens, state) + return EnkfFs.cNamespace().has_node(self, node_key, var_type, report_step, iens, state) def has_vector(self, node_key, var_type, iens, state): - return cfunc.has_vector(self, node_key, var_type, iens, state) + return EnkfFs.cNamespace().has_vector(self, node_key, var_type, iens, state) + - def fread_node(self, key, type, step, member, value): buffer = Buffer(100) - cfunc.fread_node(self, buffer, key, type, step, member, value) + EnkfFs.cNamespace().fread_node(self, buffer, key, type, step, member, value) def fread_vector(self, key, type, member, value): buffer = Buffer(100) - cfunc.fread_vector(self, buffer, key, type, member, value) + EnkfFs.cNamespace().fread_vector(self, buffer, key, type, member, value) - @property def get_time_map(self): - return TimeMap(cfunc.get_time_map(self), parent = self) + return EnkfFs.cNamespace().get_time_map(self).setParent(self) + + @classmethod + def exists(cls, path): + return cls.cNamespace().exists(path) + + def free(self): + EnkfFs.cNamespace().free(self) - @staticmethod - def exists(path): - return cfunc.exists(path) - ################################################################## -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "enkf_fs" , EnkfFs ) +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("enkf_fs", EnkfFs) +cwrapper.registerType("enkf_fs_obj", EnkfFs.createPythonObject) +cwrapper.registerType("enkf_fs_ref", EnkfFs.createCReference) -cfunc = CWrapperNameSpace("enkf_fs") - -cfunc.close = cwrapper.prototype("void enkf_fs_close(enkf_fs)") -cfunc.has_node = cwrapper.prototype("bool enkf_fs_has_node(enkf_fs, char*, c_uint, int, int, c_uint)") -cfunc.has_vector = cwrapper.prototype("bool enkf_fs_has_vector(enkf_fs, char*, c_uint, int, c_uint)") -cfunc.fread_node = cwrapper.prototype("void enkf_fs_fread_node(enkf_fs, buffer, char*, c_uint, int, int, c_uint)") -cfunc.fread_vector = cwrapper.prototype("void enkf_fs_fread_vector(enkf_fs, buffer, char*, c_uint, int, c_uint)") -cfunc.get_time_map = cwrapper.prototype("c_void_p enkf_fs_get_time_map(enkf_fs)") -cfunc.exists = cwrapper.prototype("bool enkf_fs_exists(char*)") +EnkfFs.cNamespace().close = cwrapper.prototype("void enkf_fs_close(enkf_fs)") +EnkfFs.cNamespace().has_node = cwrapper.prototype("bool enkf_fs_has_node(enkf_fs, char*, c_uint, int, int, c_uint)") +EnkfFs.cNamespace().has_vector = cwrapper.prototype("bool enkf_fs_has_vector(enkf_fs, char*, c_uint, int, c_uint)") +EnkfFs.cNamespace().fread_node = cwrapper.prototype("void enkf_fs_fread_node(enkf_fs, buffer, char*, c_uint, int, int, c_uint)") +EnkfFs.cNamespace().fread_vector = cwrapper.prototype("void enkf_fs_fread_vector(enkf_fs, buffer, char*, c_uint, int, c_uint)") +EnkfFs.cNamespace().get_time_map = cwrapper.prototype("time_map_ref enkf_fs_get_time_map(enkf_fs)") +EnkfFs.cNamespace().exists = cwrapper.prototype("bool enkf_fs_exists(char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_main.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_main.py index 229228e369..0c9e42aaf1 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_main.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_main.py @@ -12,295 +12,261 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper -import ctypes -from ert.enkf.enkf_enum import * -from ert.ert.enums import * -from ert.enkf.ens_config import * -from ert.enkf.ecl_config import * -from ert.enkf.analysis_config import * -from ert.enkf.local_config import * -from ert.enkf.model_config import * -from ert.enkf.enkf_config_node import * -from ert.enkf.gen_kw_config import * -from ert.enkf.gen_data_config import * -from ert.enkf.field_config import * -from ert.enkf.enkf_obs import * -from ert.enkf.plot_conf import * -from ert.enkf.site_config import * -from ert.enkf.libenkf import * -from ert.enkf.enkf_fs import * -from ert.enkf.ert_templates import * -from ert.enkf.enkf_state import * from ert.util import Log +from ert.enkf import AnalysisConfig, EclConfig, EnkfObs, EnKFState, ErtTemplates, LocalConfig, ModelConfig, EnsConfig, PlotConfig, SiteConfig, ENKF_LIB +from ert.util import SubstitutionList -class EnKFMain(CClass): - - - def __init(self): - pass +class EnKFMain(BaseCClass): + def __init__(self, model_config, site_config, strict=True): + c_ptr = EnKFMain.cNamespace().bootstrap(site_config, model_config, strict, False) + super(EnKFMain, self).__init__(c_ptr) - @classmethod - def bootstrap(cls , model_config , site_config , strict = True): - obj = EnKFMain() - obj.c_ptr = cfunc.bootstrap( site_config , model_config , strict , False ) - return obj - def set_eclbase(self, eclbase): - cfunc.set_eclbase(self, eclbase) - - def __del__(self): - if self.c_ptr: - cfunc.free( self ) + EnKFMain.cNamespace().set_eclbase(self, eclbase) - ################################################################# + def free(self): + EnKFMain.cNamespace().free(self) - @property def ens_size( self ): - return cfunc.ens_size( self ) - - @property - def ensemble_config(self): - config = EnsConfig( c_ptr = cfunc.get_ens_config( self ) , parent = self) - return config - - @property - def analysis_config(self): - anal_config = AnalysisConfig( c_ptr = cfunc.get_analysis_config( self ), parent = self) - return anal_config - - @property - def model_config(self): - mod_config = ModelConfig( c_ptr = cfunc.get_model_config( self ) , parent = self) - return mod_config + return EnKFMain.cNamespace().ens_size(self) + + def ensemble_config(self): + """ @rtype: EnsConfig """ + return EnKFMain.cNamespace().get_ens_config(self).setParent(self) + + def analysis_config(self): + """ @rtype: AnalysisConfig """ + return EnKFMain.cNamespace().get_analysis_config(self).setParent(self) + + def model_config(self): + """ @rtype: ModelConfig """ + return EnKFMain.cNamespace().get_model_config(self).setParent(self) - @property def logh(self): - mog = Log( c_ptr = cfunc.get_logh( self ), parent = self) - return mog - - @property + """ @rtype: Log """ + return EnKFMain.cNamespace().get_logh(self).setParent(self) + def local_config(self): - loc_config = LocalConfig( c_ptr = cfunc.get_local_config( self ), parent = self) - return loc_config - - @property + """ @rtype: LocalConfig """ + return EnKFMain.cNamespace().get_local_config(self).setParent(self) + def site_config(self): - site_conf = SiteConfig( c_ptr = cfunc.get_site_config( self ) , parent = self) - return site_conf - - @property + """ @rtype: SiteConfig """ + return EnKFMain.cNamespace().get_site_config(self).setParent(self) + def ecl_config(self): - ecl_conf = EclConfig( c_ptr = cfunc.get_ecl_config( self ) , parent = self) - return ecl_conf - - @property + """ @rtype: EclConfig """ + return EnKFMain.cNamespace().get_ecl_config(self).setParent(self) + def plot_config(self): - plot_conf = PlotConf( c_ptr = cfunc.get_plot_config( self ), parent = self) - return plot_conf - + """ @rtype: PlotConfig """ + return EnKFMain.cNamespace().get_plot_config(self).setParent(self) + def set_eclbase(self, eclbase): - cfunc.set_eclbase(self, eclbase) + EnKFMain.cNamespace().set_eclbase(self, eclbase) def set_datafile(self, datafile): - cfunc.set_eclbase(self, datafile) + EnKFMain.cNamespace().set_datafile(self, datafile) - @property def get_schedule_prediction_file(self): - schedule_prediction_file = cfunc.get_schedule_prediction_file(self) + schedule_prediction_file = EnKFMain.cNamespace().get_schedule_prediction_file(self) return schedule_prediction_file - def set_schedule_prediction_file(self,file): - cfunc.set_schedule_prediction_file(self,file) + def set_schedule_prediction_file(self, file): + EnKFMain.cNamespace().set_schedule_prediction_file(self, file) - @property - def get_data_kw(self): - data_kw = cfunc.get_data_kw(self) - return data_kw + def getDataKW(self): + """ @rtype: SubstitutionList """ + return EnKFMain.cNamespace().get_data_kw(self) - def clear_data_kw(self): - cfunc.set_data_kw(self) + def clearDataKW(self): + EnKFMain.cNamespace().clear_data_kw(self) + + def addDataKW(self, key, value): + EnKFMain.cNamespace().add_data_kw(self, key, value) - def add_data_kw(self, key, value): - cfunc.add_data_kw(self, key, value) def resize_ensemble(self, value): - cfunc.resize_ensemble(self, value) + EnKFMain.cNamespace().resize_ensemble(self, value) def del_node(self, key): - cfunc.del_node(self, key) - - @property + EnKFMain.cNamespace().del_node(self, key) + def get_obs(self): - ob = EnkfObs( c_ptr = cfunc.get_obs( self ), parent = self) - return ob - + return EnKFMain.cNamespace().get_obs(self).setParent(self) + def load_obs(self, obs_config_file): - cfunc.load_obs(self, obs_config_file) - + EnKFMain.cNamespace().load_obs(self, obs_config_file) + def reload_obs(self): - cfunc.reload_obs(self) - + EnKFMain.cNamespace().reload_obs(self) + def set_case_table(self, case_table_file): - cfunc.set_case_table(self, case_table_file) - - @property + EnKFMain.cNamespace().set_case_table(self, case_table_file) + def get_pre_clear_runpath(self): - pre_clear = cfunc.get_pre_clear_runpath(self) + pre_clear = EnKFMain.cNamespace().get_pre_clear_runpath(self) return pre_clear - + def set_pre_clear_runpath(self, value): - cfunc.set_pre_clear_runpath(self, value) - + EnKFMain.cNamespace().set_pre_clear_runpath(self, value) + def iget_keep_runpath(self, iens): - ikeep = cfunc.iget_keep_runpath(self, iens) + ikeep = EnKFMain.cNamespace().iget_keep_runpath(self, iens) return ikeep - + def iset_keep_runpath(self, iens, keep_runpath): - cfunc.iset_keep_runpath(self, iens, keep_runpath) + EnKFMain.cNamespace().iset_keep_runpath(self, iens, keep_runpath) - @property def get_templates(self): - temp = ErtTemplates( c_ptr = cfunc.get_templates( self ), parent = self) - return temp - - @property + return EnKFMain.cNamespace().get_templates(self).setParent(self) + def get_site_config_file(self): - site_conf_file = cfunc.get_site_config_file(self) + site_conf_file = EnKFMain.cNamespace().get_site_config_file(self) return site_conf_file - - def initialize_from_scratch(self, parameter_list, iens1, iens2, force_init = True): - cfunc.initialize_from_scratch(self, parameter_list, iens1, iens2, force_init) - @property + def initialize_from_scratch(self, parameter_list, iens1, iens2, force_init=True): + EnKFMain.cNamespace().initialize_from_scratch(self, parameter_list, iens1, iens2, force_init) + def get_fs(self): - return EnkfFs(c_ptr = cfunc.get_fs(self), parent = self) + """ @rtype: EnkfFs """ + return EnKFMain.cNamespace().get_fs(self).setParent(self) - @property def get_history_length(self): - return cfunc.get_history_length(self) - - def initialize_from_existing__(self, source_case,source_report_step, source_state, member_mask, ranking_key, node_list): - cfunc.initialize_from_existing__(self, source_case, source_report_step, source_state, member_mask, ranking_key, node_list) + return EnKFMain.cNamespace().get_history_length(self) - - def copy_ensemble(self, source_case, source_report_step, source_state, target_case, target_report_step, target_state, member_mask, ranking_key, node_list): - cfunc.copy_ensemble(self, source_case, source_report_step, source_state, target_case, target_report_step, target_state, member_mask, ranking_key, node_list) + def initialize_from_existing__(self, source_case, source_report_step, source_state, member_mask, ranking_key, + node_list): + EnKFMain.cNamespace().initialize_from_existing__(self, source_case, source_report_step, source_state, member_mask, ranking_key, + node_list) + + + def copy_ensemble(self, source_case, source_report_step, source_state, target_case, target_report_step, + target_state, member_mask, ranking_key, node_list): + EnKFMain.cNamespace().copy_ensemble(self, source_case, source_report_step, source_state, target_case, target_report_step, + target_state, member_mask, ranking_key, node_list) def iget_state(self, ens_memb): - i_enkf_state = EnKFState( c_ptr = cfunc.iget_state( self ,ens_memb), parent = self) - return i_enkf_state - + return EnKFMain.cNamespace().iget_state(self, ens_memb).setParent(self) + def get_observations(self, user_key, obs_count, obs_x, obs_y, obs_std): - cfunc.get_observations(self, user_key, obs_count, obs_x, obs_y, obs_std) + EnKFMain.cNamespace().get_observations(self, user_key, obs_count, obs_x, obs_y, obs_std) def get_observation_count(self, user_key): - return cfunc.get_observation_count(self, user_key) - - @property + return EnKFMain.cNamespace().get_observation_count(self, user_key) + def is_initialized(self): - return cfunc.is_initialized(self) + return EnKFMain.cNamespace().is_initialized(self) def run(self, boolPtr, init_step_parameter, simFrom, state, mode): #{"ENKF_ASSIMILATION" : 1, "ENSEMBLE_EXPERIMENT" : 2, "ENSEMBLE_PREDICTION" : 3, "INIT_ONLY" : 4, "SMOOTHER" : 5} if mode == 1: - cfunc.run_assimilation(self, boolPtr, init_step_parameter, simFrom, state) + EnKFMain.cNamespace().run_assimilation(self, boolPtr, init_step_parameter, simFrom, state) + if mode == 2: - cfunc.run_exp(self, boolPtr, True, init_step_parameter, simFrom, state) + EnKFMain.cNamespace().run_exp(self, boolPtr, True, init_step_parameter, simFrom, state, True) + if mode == 4: - cfunc.run_exp(self, boolPtr, False, init_step_parameter, simFrom, state) + EnKFMain.cNamespace().run_exp(self, boolPtr, False, init_step_parameter, simFrom, state , True) + if mode == 5: - cfunc.run_smoother(self, "AUTOSMOOTHER", True) + EnKFMain.cNamespace().run_smoother(self, "AUTOSMOOTHER", True) - @property def alloc_caselist(self): - return StringList(c_ptr = cfunc.alloc_caselist(self), parent = self) + return EnKFMain.cNamespace().alloc_caselist(self).setParent(self) - @property def get_current_fs(self): - return cfunc.get_current_fs(self) + """ @rtype: EnkfFs """ + return EnKFMain.cNamespace().get_current_fs(self) def user_select_fs(self, input_case): - cfunc.user_select_fs(self, input_case) + EnKFMain.cNamespace().user_select_fs(self, input_case) - @property def get_alt_fs(self, fs, read_only, create): - return EnkfFS(cfunc.get_alt_fs(self, fs, read_only, create), parent = self) + """ @rtype: EnkfFs """ + return EnKFMain.cNamespace().get_alt_fs(self, fs, read_only, create).setParent(self) - @staticmethod - def create_new_config(config_file, storage_path, case_name, dbase_type, num_realizations): - cfunc.create_new_config(config_file, storage_path, case_name, dbase_type, num_realizations) + def createNewConfig(config_file, storage_path, case_name, dbase_type, num_realizations): + EnKFMain.cNamespace().create_new_config(config_file, storage_path, case_name, dbase_type, num_realizations) def fprintf_config(self): - cfunc.fprintf_config(self) + EnKFMain.cNamespace().fprintf_config(self) - def select_fs(self,path): - cfunc.select_fs(self,path) - - def fs_exists(self,case): - return cfunc.fs_exists(self,case) - -################################################################## + def select_fs(self, path): + EnKFMain.cNamespace().select_fs(self, path) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "enkf_main" , EnKFMain ) + def fs_exists(self, case): + return EnKFMain.cNamespace().fs_exists(self, case) -cfunc = CWrapperNameSpace("enkf_main") + def saveConfig(self): + #EnKFMain.cNamespace().fprintf_config(self) + pass -################################################################## ################################################################## -cfunc.bootstrap = cwrapper.prototype("c_void_p enkf_main_bootstrap(char*, char*, bool , bool)") -cfunc.free = cwrapper.prototype("void enkf_main_free( enkf_main )") -cfunc.ens_size = cwrapper.prototype("int enkf_main_get_ensemble_size( enkf_main )") -cfunc.get_ens_config = cwrapper.prototype("c_void_p enkf_main_get_ensemble_config( enkf_main )") -cfunc.get_model_config = cwrapper.prototype("c_void_p enkf_main_get_model_config( enkf_main )") -cfunc.get_local_config = cwrapper.prototype("c_void_p enkf_main_get_local_config( enkf_main )") -cfunc.get_analysis_config = cwrapper.prototype("c_void_p enkf_main_get_analysis_config( enkf_main)") -cfunc.get_site_config = cwrapper.prototype("c_void_p enkf_main_get_site_config( enkf_main)") -cfunc.get_ecl_config = cwrapper.prototype("c_void_p enkf_main_get_ecl_config( enkf_main)") -cfunc.get_plot_config = cwrapper.prototype("c_void_p enkf_main_get_plot_config( enkf_main)") -cfunc.set_eclbase = cwrapper.prototype("void enkf_main_set_eclbase( enkf_main, char*)") -cfunc.set_datafile = cwrapper.prototype("void enkf_main_set_data_file( enkf_main, char*)") -cfunc.get_schedule_prediction_file = cwrapper.prototype("char* enkf_main_get_schedule_prediction_file( enkf_main )") -cfunc.set_schedule_prediction_file = cwrapper.prototype("void enkf_main_set_schedule_prediction_file( enkf_main , char*)") -cfunc.get_data_kw = cwrapper.prototype("c_void_p enkf_main_get_data_kw(enkf_main)") -cfunc.clear_data_kw = cwrapper.prototype("void enkf_main_clear_data_kw(enkf_main)") -cfunc.add_data_kw = cwrapper.prototype("void enkf_main_add_data_kw(enkf_main, char*, char*)") -cfunc.resize_ensemble = cwrapper.prototype("void enkf_main_resize_ensemble(enkf_main, int)") -cfunc.del_node = cwrapper.prototype("void enkf_main_del_node(enkf_main, char*)") -cfunc.get_obs = cwrapper.prototype("c_void_p enkf_main_get_obs(enkf_main)") -cfunc.load_obs = cwrapper.prototype("void enkf_main_load_obs(enkf_main, char*)") -cfunc.reload_obs = cwrapper.prototype("void enkf_main_reload_obs(enkf_main)") -cfunc.set_case_table = cwrapper.prototype("void enkf_main_set_case_table(enkf_main, char*)") -cfunc.get_pre_clear_runpath = cwrapper.prototype("bool enkf_main_get_pre_clear_runpath(enkf_main)") -cfunc.set_pre_clear_runpath = cwrapper.prototype("void enkf_main_set_pre_clear_runpath(enkf_main, bool)") -cfunc.iget_keep_runpath = cwrapper.prototype("int enkf_main_iget_keep_runpath(enkf_main, int)") -cfunc.iset_keep_runpath = cwrapper.prototype("void enkf_main_iset_keep_runpath(enkf_main, int, int_vector)") -cfunc.get_templates = cwrapper.prototype("c_void_p enkf_main_get_templates(enkf_main)") -cfunc.get_site_config_file = cwrapper.prototype("char* enkf_main_get_site_config_file(enkf_main)") -cfunc.initialize_from_scratch = cwrapper.prototype("void enkf_main_initialize_from_scratch(enkf_main, stringlist, int, int, bool)") -cfunc.get_fs = cwrapper.prototype("c_void_p enkf_main_get_fs(enkf_main)") -cfunc.get_history_length = cwrapper.prototype("int enkf_main_get_history_length(enkf_main)") -cfunc.initialize_from_existing__ = cwrapper.prototype("void enkf_main_initialize_from_existing__(enkf_main, char*, int, int, bool_vector, char*, stringlist)") -cfunc.copy_ensemble = cwrapper.prototype("void enkf_main_copy_ensemble(enkf_main, char*, int, int, char*, int, int, bool_vector, char*, stringlist)") -cfunc.get_observations = cwrapper.prototype("void enkf_main_get_observations(enkf_main, char*, int, long*, double*, double*)") -cfunc.get_observation_count = cwrapper.prototype("int enkf_main_get_observation_count(enkf_main, char*)") -cfunc.get_alt_fs = cwrapper.prototype("c_void_p enkf_main_get_alt_fs(enkf_main , char* , bool , bool)") -cfunc.is_initialized = cwrapper.prototype("bool enkf_main_is_initialized(enkf_main)") -cfunc.iget_state = cwrapper.prototype("c_void_p enkf_main_iget_state(enkf_main, int)") -cfunc.user_select_fs = cwrapper.prototype("void enkf_main_user_select_fs(enkf_main , char*)") -cfunc.get_logh = cwrapper.prototype("void enkf_main_get_logh( enkf_main )") -cfunc.run_exp = cwrapper.prototype("void enkf_main_run_exp( enkf_main, bool_vector, bool, int, int, int)") -cfunc.run_assimilation = cwrapper.prototype("void enkf_main_run_assimilation( enkf_main, bool_vector, int, int, int)") -cfunc.run_smoother = cwrapper.prototype("void enkf_main_run_smoother(enkf_main, char*, bool)") -cfunc.get_current_fs = cwrapper.prototype("char* enkf_main_get_current_fs(enkf_main)") -cfunc.alloc_caselist = cwrapper.prototype("c_void_p enkf_main_alloc_caselist(enkf_main)") -cfunc.fprintf_config = cwrapper.prototype("void enkf_main_fprintf_config(enkf_main)") -cfunc.create_new_config = cwrapper.prototype("void enkf_main_create_new_config(char* , char*, char* , char* , int)") -cfunc.select_fs = cwrapper.prototype("void enkf_main_select_fs(enkf_main, char*)") -cfunc.fs_exists = cwrapper.prototype("bool enkf_main_fs_exists(enkf_main, char*)") +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("enkf_main", EnKFMain) + + +EnKFMain.cNamespace().bootstrap = cwrapper.prototype("c_void_p enkf_main_bootstrap(char*, char*, bool, bool)") +EnKFMain.cNamespace().free = cwrapper.prototype("void enkf_main_free(enkf_main)") + +EnKFMain.cNamespace().ens_size = cwrapper.prototype("int enkf_main_get_ensemble_size( enkf_main )") +EnKFMain.cNamespace().get_ens_config = cwrapper.prototype("ens_config_ref enkf_main_get_ensemble_config( enkf_main )") +EnKFMain.cNamespace().get_model_config = cwrapper.prototype("model_config_ref enkf_main_get_model_config( enkf_main )") +EnKFMain.cNamespace().get_local_config = cwrapper.prototype("local_config_ref enkf_main_get_local_config( enkf_main )") +EnKFMain.cNamespace().get_analysis_config = cwrapper.prototype("analysis_config_ref enkf_main_get_analysis_config( enkf_main)") +EnKFMain.cNamespace().get_site_config = cwrapper.prototype("site_config_ref enkf_main_get_site_config( enkf_main)") +EnKFMain.cNamespace().get_ecl_config = cwrapper.prototype("ecl_config_ref enkf_main_get_ecl_config( enkf_main)") +EnKFMain.cNamespace().get_plot_config = cwrapper.prototype("plot_config_ref enkf_main_get_plot_config( enkf_main)") +EnKFMain.cNamespace().set_eclbase = cwrapper.prototype("void enkf_main_set_eclbase( enkf_main, char*)") +EnKFMain.cNamespace().set_datafile = cwrapper.prototype("void enkf_main_set_data_file( enkf_main, char*)") +EnKFMain.cNamespace().get_schedule_prediction_file = cwrapper.prototype("char* enkf_main_get_schedule_prediction_file( enkf_main )") +EnKFMain.cNamespace().set_schedule_prediction_file = cwrapper.prototype("void enkf_main_set_schedule_prediction_file( enkf_main , char*)") + +EnKFMain.cNamespace().get_data_kw = cwrapper.prototype("subst_list_ref enkf_main_get_data_kw(enkf_main)") +EnKFMain.cNamespace().clear_data_kw = cwrapper.prototype("void enkf_main_clear_data_kw(enkf_main)") +EnKFMain.cNamespace().add_data_kw = cwrapper.prototype("void enkf_main_add_data_kw(enkf_main, char*, char*)") + +EnKFMain.cNamespace().resize_ensemble = cwrapper.prototype("void enkf_main_resize_ensemble(enkf_main, int)") +EnKFMain.cNamespace().del_node = cwrapper.prototype("void enkf_main_del_node(enkf_main, char*)") +EnKFMain.cNamespace().get_obs = cwrapper.prototype("enkf_obs_ref enkf_main_get_obs(enkf_main)") +EnKFMain.cNamespace().load_obs = cwrapper.prototype("void enkf_main_load_obs(enkf_main, char*)") +EnKFMain.cNamespace().reload_obs = cwrapper.prototype("void enkf_main_reload_obs(enkf_main)") +EnKFMain.cNamespace().set_case_table = cwrapper.prototype("void enkf_main_set_case_table(enkf_main, char*)") +EnKFMain.cNamespace().get_pre_clear_runpath = cwrapper.prototype("bool enkf_main_get_pre_clear_runpath(enkf_main)") +EnKFMain.cNamespace().set_pre_clear_runpath = cwrapper.prototype("void enkf_main_set_pre_clear_runpath(enkf_main, bool)") +EnKFMain.cNamespace().iget_keep_runpath = cwrapper.prototype("int enkf_main_iget_keep_runpath(enkf_main, int)") +EnKFMain.cNamespace().iset_keep_runpath = cwrapper.prototype("void enkf_main_iset_keep_runpath(enkf_main, int, int_vector)") +EnKFMain.cNamespace().get_templates = cwrapper.prototype("ert_templates_ref enkf_main_get_templates(enkf_main)") +EnKFMain.cNamespace().get_site_config_file = cwrapper.prototype("char* enkf_main_get_site_config_file(enkf_main)") +EnKFMain.cNamespace().initialize_from_scratch = cwrapper.prototype("void enkf_main_initialize_from_scratch(enkf_main, stringlist, int, int, bool)") +EnKFMain.cNamespace().get_history_length = cwrapper.prototype("int enkf_main_get_history_length(enkf_main)") +EnKFMain.cNamespace().initialize_from_existing__ = cwrapper.prototype("void enkf_main_initialize_from_existing__(enkf_main, char*, int, int, bool_vector, char*, stringlist)") +EnKFMain.cNamespace().copy_ensemble = cwrapper.prototype("void enkf_main_copy_ensemble(enkf_main, char*, int, int, char*, int, int, bool_vector, char*, stringlist)") +EnKFMain.cNamespace().get_observations = cwrapper.prototype("void enkf_main_get_observations(enkf_main, char*, int, long*, double*, double*)") +EnKFMain.cNamespace().get_observation_count = cwrapper.prototype("int enkf_main_get_observation_count(enkf_main, char*)") +EnKFMain.cNamespace().is_initialized = cwrapper.prototype("bool enkf_main_is_initialized(enkf_main)") +EnKFMain.cNamespace().iget_state = cwrapper.prototype("enkf_state_ref enkf_main_iget_state(enkf_main, int)") + +EnKFMain.cNamespace().get_logh = cwrapper.prototype("log_ref enkf_main_get_logh( enkf_main )") + +EnKFMain.cNamespace().run_exp = cwrapper.prototype("void enkf_main_run_exp( enkf_main, bool_vector, bool, int, int, int, bool)") +EnKFMain.cNamespace().run_assimilation = cwrapper.prototype("void enkf_main_run_assimilation( enkf_main, bool_vector, int, int, int)") +EnKFMain.cNamespace().run_smoother = cwrapper.prototype("void enkf_main_run_smoother(enkf_main, char*, bool)") +EnKFMain.cNamespace().alloc_caselist = cwrapper.prototype("stringlist_ref enkf_main_alloc_caselist(enkf_main)") +EnKFMain.cNamespace().fprintf_config = cwrapper.prototype("void enkf_main_fprintf_config(enkf_main)") +EnKFMain.cNamespace().create_new_config = cwrapper.prototype("void enkf_main_create_new_config(char* , char*, char* , char* , int)") + +EnKFMain.cNamespace().get_fs = cwrapper.prototype("enkf_fs_ref enkf_main_get_fs(enkf_main)") +EnKFMain.cNamespace().get_alt_fs = cwrapper.prototype("enkf_fs_ref enkf_main_get_alt_fs(enkf_main , char* , bool , bool)") +EnKFMain.cNamespace().user_select_fs = cwrapper.prototype("void enkf_main_user_select_fs(enkf_main , char*)") +EnKFMain.cNamespace().get_current_fs = cwrapper.prototype("char* enkf_main_get_current_fs(enkf_main)") +EnKFMain.cNamespace().select_fs = cwrapper.prototype("void enkf_main_select_fs(enkf_main, char*)") +EnKFMain.cNamespace().fs_exists = cwrapper.prototype("bool enkf_main_fs_exists(enkf_main, char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_node.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_node.py deleted file mode 100644 index 0b51273fa6..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_node.py +++ /dev/null @@ -1,66 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'enkf_node.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -from ert.enkf.enkf_fs import EnkfFs -from ert.util.tvector import DoubleVector -import libenkf -class EnkfNode(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @staticmethod - def alloc(config_node): - node = EnkfNode(c_ptr = cfunc.alloc( config_node ) , parent = config_node) - return node - - def user_get(self, fs, key, report_step, iens, state, value): - return cfunc.user_get(self, fs, key, report_step, iens, state, value) - - def user_get_vector( self , fs , key , iens , state , vector): - return cfunc.user_get_vector( self , fs , key , iens , state, vector) - - def value_ptr(self): - cfunc.value_ptr(self) - - @property - def vector_storage(self): - return cfunc.vector_storage(self) -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "enkf_node" , EnkfNode ) - -# 3. Installing the c-functions used to manipulate ecl_kw instances. -# These functions are used when implementing the EclKW class, not -# used outside this scope. -cfunc = CWrapperNameSpace("enkf_node") - - -cfunc.free = cwrapper.prototype("void enkf_node_free( enkf_node )") -cfunc.alloc = cwrapper.prototype("c_void_p enkf_node_alloc( enkf_node)") -cfunc.user_get = cwrapper.prototype("bool enkf_node_user_get_no_id(enkf_node , enkf_fs , char* , int, int , c_uint, double*)") -cfunc.user_get_vector = cwrapper.prototype("bool enkf_node_user_get_vector( enkf_node , enkf_fs , char*, int, c_uint, double_vector)") -cfunc.value_ptr = cwrapper.prototype("void enkf_node_value_ptr(enkf_node)") -cfunc.vector_storage = cwrapper.prototype("bool enkf_node_vector_storage(enkf_node)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_obs.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_obs.py index 0ebf92ff64..53799c30fa 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_obs.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_obs.py @@ -12,53 +12,50 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -from ert.util.stringlist import StringList -from ert.enkf.obs_vector import ObsVector +from ert.util import StringList +from ert.enkf.util import ObsVector -class EnkfObs(CClass): + +class EnkfObs(BaseCClass): - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + def get_config_file(self): - return cfunc.get_config_file(self) + """ @rtype: Str """ + return EnkfObs.cNamespace().get_config_file(self) def alloc_typed_keylist(self, type): - return StringList(c_ptr = cfunc.alloc_typed_keylist(self, type), parent = self) + """ @rtype: StringList """ + return EnkfObs.cNamespace().alloc_typed_keylist(self, type).setParent(self) - @property def has_key(self, key): - return cfunc.has_key(self, key) + """ @rtype: bool """ + return EnkfObs.cNamespace().has_key(self, key) - @property def get_vector(self, key): - return ObsVector(cfunc.get_vector(self,key), parent = self) + """ @rtype: ObsVector """ + return EnkfObs.cNamespace().get_vector(self,key).setParent(self) -################################################################## + def free(self): + EnkfObs.cNamespace().free(self) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "enkf_obs" , EnkfObs ) + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("enkf_obs", EnkfObs) +cwrapper.registerType("enkf_obs_obj", EnkfObs.createPythonObject) +cwrapper.registerType("enkf_obs_ref", EnkfObs.createCReference) # 3. Installing the c-functions used to manipulate ecl_kw instances. # These functions are used when implementing the EclKW class, not # used outside this scope. -cfunc = CWrapperNameSpace("enkf_obs") - -cfunc.free = cwrapper.prototype("void enkf_obs_free( enkf_obs )") -cfunc.get_config_file = cwrapper.prototype("char* enkf_obs_get_config_file( enkf_obs )") -cfunc.alloc_typed_keylist = cwrapper.prototype("c_void_p enkf_obs_alloc_typed_keylist(enkf_obs, int)") -cfunc.has_key = cwrapper.prototype("bool enkf_obs_has_key(enkf_obs, char*)") -cfunc.get_vector = cwrapper.prototype("c_void_p enkf_obs_get_vector(enkf_obs, char*)") +EnkfObs.cNamespace().free = cwrapper.prototype("void enkf_obs_free( enkf_obs )") +EnkfObs.cNamespace().get_config_file = cwrapper.prototype("char* enkf_obs_get_config_file( enkf_obs )") +EnkfObs.cNamespace().alloc_typed_keylist = cwrapper.prototype("stringlist_ref enkf_obs_alloc_typed_keylist(enkf_obs, int)") +EnkfObs.cNamespace().has_key = cwrapper.prototype("bool enkf_obs_has_key(enkf_obs, char*)") +EnkfObs.cNamespace().get_vector = cwrapper.prototype("obs_vector_ref enkf_obs_get_vector(enkf_obs, char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_state.py b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_state.py index 0522ca7cf7..aff4a60e1b 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_state.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/enkf_state.py @@ -12,53 +12,41 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -from ert.util.ctime import ctime -#from ert.util.ctime import time_t -class EnKFState(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) + +class EnKFState(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") def kill_simulation(self): - cfunc.kill_simulation(self) - + EnKFState.cNamespace().kill_simulation(self) + def resubmit_simulation(self, sim_number): - cfunc.resubmit_simulation(self, sim_number) - - @property + EnKFState.cNamespace().resubmit_simulation(self, sim_number) + def get_run_status(self): - return cfunc.get_run_status(self) - - @property + return EnKFState.cNamespace().get_run_status(self) + def get_start_time(self): - return cfunc.get_start_time(self) - - @property + return EnKFState.cNamespace().get_start_time(self) + def get_submit_time(self): - return cfunc.get_submit_time(self) -################################################################## + return EnKFState.cNamespace().get_submit_time(self) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "enkf_state" , EnKFState ) + def free(self): + EnKFState.cNamespace().free(self) -cfunc = CWrapperNameSpace("enkf_state") +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("enkf_state", EnKFState) +cwrapper.registerType("enkf_state_obj", EnKFState.createPythonObject) +cwrapper.registerType("enkf_state_ref", EnKFState.createCReference) -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void enkf_state_free( enkf_state )") -cfunc.kill_simulation = cwrapper.prototype("void enkf_state_kill_simulation(enkf_state)") -cfunc.resubmit_simulation = cwrapper.prototype("void enkf_state_resubmit_simulation(enkf_state, int)") -cfunc.get_run_status = cwrapper.prototype("int enkf_state_get_run_status(enkf_state)") -cfunc.get_start_time = cwrapper.prototype("int enkf_state_get_start_time(enkf_state)") -cfunc.get_submit_time = cwrapper.prototype("int enkf_state_get_submit_time(enkf_state)") +EnKFState.cNamespace().free = cwrapper.prototype("void enkf_state_free( enkf_state )") +EnKFState.cNamespace().kill_simulation = cwrapper.prototype("void enkf_state_kill_simulation(enkf_state)") +EnKFState.cNamespace().resubmit_simulation = cwrapper.prototype("void enkf_state_resubmit_simulation(enkf_state, int)") +EnKFState.cNamespace().get_run_status = cwrapper.prototype("int enkf_state_get_run_status(enkf_state)") +EnKFState.cNamespace().get_start_time = cwrapper.prototype("int enkf_state_get_start_time(enkf_state)") +EnKFState.cNamespace().get_submit_time = cwrapper.prototype("int enkf_state_get_submit_time(enkf_state)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/ens_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/ens_config.py index b5a689a9cc..4c1c214881 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/ens_config.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/ens_config.py @@ -12,70 +12,64 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB +from ert.enkf.data import EnkfConfigNode +from ert.util import StringList -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from ert.enkf.enkf_enum import * -import ert.enkf.libenkf -from ert.ecl.ecl_grid import EclGrid -from ert.enkf.enkf_config_node import EnkfConfigNode -from ert.util.stringlist import StringList -class EnsConfig(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - def has_key(self , key): - return cfunc.has_key( self ,key ) +class EnsConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def has_key(self, key): + """ @rtype: bool """ + return EnsConfig.cNamespace().has_key(self, key) def get_node(self, key): - node = EnkfConfigNode( cfunc.get_node(self, key), parent = self) - return node - - @property + """ @rtype: EnkfConfigNode """ + return EnsConfig.cNamespace().get_node(self, key).setParent(self) + def alloc_keylist(self): - key_list = StringList( c_ptr = cfunc.alloc_keylist(self), parent = self) - return key_list - + """ @rtype: StringList """ + return EnsConfig.cNamespace().alloc_keylist(self).setParent(self) + def add_summary(self, key): - node = EnkfConfigNode( cfunc.add_summary(self, key, 2), parent = self) - return node + """ @rtype: EnkfConfigNode """ + return EnsConfig.cNamespace().add_summary(self, key, 2).setParent(self) def add_gen_kw(self, key): - node = EnkfConfigNode( cfunc.add_gen_kw(self, key), parent = self) - return node + """ @rtype: EnkfConfigNode """ + return EnsConfig.cNamespace().add_gen_kw(self, key).setParent(self) def add_gen_data(self, key): - node = EnkfConfigNode( cfunc.add_gen_data(self, key), parent = self) - return node - + """ @rtype: EnkfConfigNode """ + return EnsConfig.cNamespace().add_gen_data(self, key).setParent(self) + def add_field(self, key, eclipse_grid): - node = EnkfConfigNode( cfunc.add_field(self, key, eclipse_grid), parent = self) - return node - + """ @rtype: EnkfConfigNode """ + return EnsConfig.cNamespace().add_field(self, key, eclipse_grid).setParent(self) + def alloc_keylist_from_var_type(self, var_mask): - return StringList(c_ptr = cfunc.alloc_keylist_from_var_type(self,var_mask), parent = self) + """ @rtype: StringList """ + return EnsConfig.cNamespace().alloc_keylist_from_var_type(self, var_mask).setParent(self) -################################################################## + def free(self): + EnsConfig.cNamespace().free(self) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "ens_config" , EnsConfig ) -cfunc = CWrapperNameSpace("ens_config") +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("ens_config", EnsConfig) +cwrapper.registerType("ens_config_obj", EnsConfig.createPythonObject) +cwrapper.registerType("ens_config_ref", EnsConfig.createCReference) -cfunc.free = cwrapper.prototype("void ensemble_config_free( ens_config )") -cfunc.has_key = cwrapper.prototype("bool ensemble_config_has_key( ens_config , char* )") -cfunc.get_node = cwrapper.prototype("c_void_p ensemble_config_get_node( ens_config , char*)") -cfunc.alloc_keylist = cwrapper.prototype("c_void_p ensemble_config_alloc_keylist( ens_config )") -cfunc.add_summary = cwrapper.prototype("c_void_p ensemble_config_add_summary( ens_config, char*, int)") -cfunc.add_gen_kw = cwrapper.prototype("c_void_p ensemble_config_add_gen_kw( ens_config, char*)") -cfunc.add_gen_data = cwrapper.prototype("c_void_p ensemble_config_add_gen_data( ens_config, char*)") -cfunc.add_field = cwrapper.prototype("c_void_p ensemble_config_add_field( ens_config, char*, ecl_grid)") -cfunc.alloc_keylist_from_var_type = cwrapper.prototype("c_void_p ensemble_config_alloc_keylist_from_var_type(ens_config, int)") +EnsConfig.cNamespace().free = cwrapper.prototype("void ensemble_config_free( ens_config )") +EnsConfig.cNamespace().has_key = cwrapper.prototype("bool ensemble_config_has_key( ens_config , char* )") +EnsConfig.cNamespace().get_node = cwrapper.prototype("enkf_config_node_ref ensemble_config_get_node( ens_config , char*)") +EnsConfig.cNamespace().alloc_keylist = cwrapper.prototype("stringlist_ref ensemble_config_alloc_keylist( ens_config )") +EnsConfig.cNamespace().add_summary = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_summary( ens_config, char*, int)") +EnsConfig.cNamespace().add_gen_kw = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_gen_kw( ens_config, char*)") +EnsConfig.cNamespace().add_gen_data = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_gen_data( ens_config, char*)") +EnsConfig.cNamespace().add_field = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_field( ens_config, char*, ecl_grid)") +EnsConfig.cNamespace().alloc_keylist_from_var_type = cwrapper.prototype("stringlist_ref ensemble_config_alloc_keylist_from_var_type(ens_config, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/ert_template.py b/ThirdParty/Ert/devel/python/python/ert/enkf/ert_template.py index 59d763a6ad..be9d06e492 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/ert_template.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/ert_template.py @@ -12,42 +12,36 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import CWrapper, BaseCClass +from ert.enkf import ENKF_LIB -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -class ErtTemplate(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - @property +class ErtTemplate(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + def get_template_file(self): - return cfunc.get_template_file(self) + """ @rtype: str """ + return ErtTemplate.cNamespace().get_template_file(self) - @property def get_target_file(self): - return cfunc.get_target_file(self) + """ @rtype: str """ + return ErtTemplate.cNamespace().get_target_file(self) - @property def get_args_as_string(self): - return cfunc.get_args_as_string(self) -################################################################## + """ @rtype: str """ + return ErtTemplate.cNamespace().get_args_as_string(self) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "ert_template" , ErtTemplate ) + def free(self): + ErtTemplate.cNamespace().free(self) -cfunc = CWrapperNameSpace("ert_template") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void ert_template_free( ert_template )") -cfunc.get_template_file = cwrapper.prototype("char* ert_template_get_template_file(ert_template)") -cfunc.get_target_file = cwrapper.prototype("char* ert_template_get_target_file(ert_template)") -cfunc.get_args_as_string = cwrapper.prototype("char* ert_template_get_args_as_string(ert_template)") +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("ert_template", ErtTemplate) +cwrapper.registerType("ert_template_obj", ErtTemplate.createPythonObject) +cwrapper.registerType("ert_template_ref", ErtTemplate.createCReference) + +ErtTemplate.cNamespace().free = cwrapper.prototype("void ert_template_free( ert_template )") +ErtTemplate.cNamespace().get_template_file = cwrapper.prototype("char* ert_template_get_template_file(ert_template)") +ErtTemplate.cNamespace().get_target_file = cwrapper.prototype("char* ert_template_get_target_file(ert_template)") +ErtTemplate.cNamespace().get_args_as_string = cwrapper.prototype("char* ert_template_get_args_as_string(ert_template)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/ert_templates.py b/ThirdParty/Ert/devel/python/python/ert/enkf/ert_templates.py index fe7170c6f6..dbbcd7de2b 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/ert_templates.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/ert_templates.py @@ -12,51 +12,43 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB, ErtTemplate +from ert.util import StringList -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -from ert.util.stringlist import StringList -from ert.enkf.ert_template import ErtTemplate -class ErtTemplates(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def alloc_list(self): - return StringList(c_ptr = cfunc.alloc_list(self), parent = self) + + +class ErtTemplates(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def getTemplateNames(self): + """ @rtype: StringList """ + return ErtTemplates.cNamespace().alloc_list(self).setParent(self) def clear(self): - cfunc.clear(self) + ErtTemplates.cNamespace().clear(self) - def get_template(self,key): - template = ErtTemplate( cfunc.get_template( self, key ), parent = self) - return template + def get_template(self, key): + """ @rtype: ErtTemplate """ + return ErtTemplates.cNamespace().get_template(self, key).setParent(self) - @property def add_template(self, key, template_file, target_file, arg_string): - return ErtTemplate(cfunc.add_template(self, key, template_file, target_file, arg_string), parent = self) + """ @rtype: ErtTemplate """ + return ErtTemplates.cNamespace().add_template(self, key, template_file, target_file, arg_string).setParent(self) + + def free(self): + ErtTemplates.cNamespace().free(self) +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("ert_templates", ErtTemplates) +cwrapper.registerType("ert_templates_obj", ErtTemplates.createPythonObject) +cwrapper.registerType("ert_templates_ref", ErtTemplates.createCReference) -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "ert_templates" , ErtTemplates ) - -cfunc = CWrapperNameSpace("ert_templates") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void ert_templates_free( ert_templates )") -cfunc.alloc_list = cwrapper.prototype("c_void_p ert_templates_alloc_list(ert_templates)") -cfunc.get_template = cwrapper.prototype("c_void_p ert_templates_get_template(ert_templates, char*)") -cfunc.clear = cwrapper.prototype("void ert_templates_clear(ert_templates)") -cfunc.add_template = cwrapper.prototype("void ert_templates_add_template(ert_templates, char*, char*, char*, char*)") +ErtTemplates.cNamespace().free = cwrapper.prototype("void ert_templates_free( ert_templates )") +ErtTemplates.cNamespace().alloc_list = cwrapper.prototype("stringlist_ref ert_templates_alloc_list(ert_templates)") +ErtTemplates.cNamespace().get_template = cwrapper.prototype("ert_template_ref ert_templates_get_template(ert_templates, char*)") +ErtTemplates.cNamespace().clear = cwrapper.prototype("void ert_templates_clear(ert_templates)") +ErtTemplates.cNamespace().add_template = cwrapper.prototype("ert_template_ref ert_templates_add_template(ert_templates, char*, char*, char*, char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/field.py b/ThirdParty/Ert/devel/python/python/ert/enkf/field.py deleted file mode 100644 index 679f114ebf..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/field.py +++ /dev/null @@ -1,48 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'field.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -class FieldObs(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - def ijk_get_double(self , i,j,k): - return cfunc.ijk_get_double( self ,i,j,k ) - - - -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "field" , FieldObs ) - -# 3. Installing the c-functions used to manipulate ecl_kw instances. -# These functions are used when implementing the EclKW class, not -# used outside this scope. -cfunc = CWrapperNameSpace("field") - - -cfunc.free = cwrapper.prototype("void field_free( field )") -cfunc.ijk_get_double = cwrapper.prototype("double field_ijk_get_double(field, int, int, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/field_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/field_config.py deleted file mode 100644 index 6f333cc876..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/field_config.py +++ /dev/null @@ -1,87 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'field_config.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -class FieldConfig(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_type(self): - return cfunc.get_type(self) - - @property - def get_truncation_mode(self): - return cfunc.get_truncation_mode(self) - - @property - def get_truncation_min(self): - return cfunc.get_truncation_min(self) - - @property - def get_init_transform_name(self): - return cfunc.get_init_transform_name(self) - - @property - def get_output_transform_name(self): - return cfunc.get_output_transform_name(self) - - @property - def get_truncation_max(self): - return cfunc.get_truncation_max(self) - - @property - def get_nx(self): - return cfunc.get_nx(self) - - @property - def get_ny(self): - return cfunc.get_ny(self) - - @property - def get_nz(self): - return cfunc.get_ny(self) - - def ijk_active(self, i,j,k): - return cfunc.ijk_active(self,i,j,k) -################################################################## -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "field_config" , FieldConfig ) - -cfunc = CWrapperNameSpace("field_config") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void field_config_free( field_config )") -cfunc.get_type = cwrapper.prototype("int field_config_get_type(field_config)") -cfunc.get_truncation_mode = cwrapper.prototype("int field_config_get_truncation_mode(field_config)") -cfunc.get_truncation_min = cwrapper.prototype("double field_config_get_truncation_min(field_config)") -cfunc.get_truncation_max = cwrapper.prototype("double field_config_get_truncation_max(field_config)") -cfunc.get_init_transform_name = cwrapper.prototype("char* field_config_get_init_transform_name(field_config)") -cfunc.get_output_transform_name = cwrapper.prototype("char* field_config_get_output_transform_name(field_config)") -cfunc.ijk_active = cwrapper.prototype("bool field_config_ijk_active(field_config, int, int, int)") -cfunc.get_nx = cwrapper.prototype("int field_config_get_nx(field_config)") -cfunc.get_ny = cwrapper.prototype("int field_config_get_ny(field_config)") -cfunc.get_nz = cwrapper.prototype("int field_config_get_nz(field_config)") -cfunc.get_grid = cwrapper.prototype("c_void_p field_config_get_grid(field_config)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/gen_data_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/gen_data_config.py deleted file mode 100644 index 39144f0580..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/gen_data_config.py +++ /dev/null @@ -1,71 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'gen_data_config.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf - -class GenDataConfig(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_template_file(self): - return cfunc.get_template_file(self) - - @property - def get_template_key(self): - return cfunc.get_template_key(self) - - @property - def get_initial_size(self): - return cfunc.get_initial_size(self) - - @property - def get_output_format(self): - return cfunc.get_output_format(self) - - @property - def get_input_format(self): - return cfunc.get_input_format(self) - - - -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "gen_data_config" , GenDataConfig ) - -# 3. Installing the c-functions used to manipulate ecl_kw instances. -# These functions are used when implementing the EclKW class, not -# used outside this scope. -cfunc = CWrapperNameSpace("gen_data_config") - - -cfunc.free = cwrapper.prototype("void gen_data_config_free( gen_data_config )") -cfunc.get_output_format = cwrapper.prototype("c_void_p gen_data_config_get_output_format(gen_data_config)") -cfunc.get_input_format = cwrapper.prototype("c_void_p gen_data_config_get_input_format(gen_data_config)") -cfunc.get_template_file = cwrapper.prototype("char* gen_data_config_get_template_file(gen_data_config)") -cfunc.get_template_key = cwrapper.prototype("char* gen_data_config_get_template_key(gen_data_config)") -cfunc.get_initial_size = cwrapper.prototype("int gen_data_config_get_initial_size(gen_data_config)") - diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/gen_kw_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/gen_kw_config.py deleted file mode 100644 index afe9def000..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/gen_kw_config.py +++ /dev/null @@ -1,55 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'gen_kw_config.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from ert.enkf.enkf_enum import * -import ert.enkf.libenkf -from ert.util.stringlist import StringList -class GenKwConfig(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_template_file(self): - return cfunc.get_template_file(self) - - @property - def get_parameter_file(self): - return cfunc.get_parameter_file(self) - - @property - def alloc_name_list(self): - return StringList(c_ptr = cfunc.alloc_name_list(self), parent = self) - -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "gen_kw_config" , GenKwConfig ) - -cfunc = CWrapperNameSpace("gen_kw_config") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void gen_kw_config_free( gen_kw_config )") -cfunc.get_template_file = cwrapper.prototype("char* gen_kw_config_get_template_file(gen_kw_config)") -cfunc.get_parameter_file = cwrapper.prototype("char* gen_kw_config_get_parameter_file(gen_kw_config)") -cfunc.alloc_name_list = cwrapper.prototype("c_void_p gen_kw_config_alloc_name_list(gen_kw_config)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/libenkf.py b/ThirdParty/Ert/devel/python/python/ert/enkf/libenkf.py deleted file mode 100644 index 5adf6f9361..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/libenkf.py +++ /dev/null @@ -1,26 +0,0 @@ -# Copyright (C) 2011 Statoil ASA, Norway. -# -# The file 'libenkf.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ert.util -import ert.ecl -import ert.job_queue -import ert.rms.librms -import ert.cwrap.clib as clib - -clib.ert_load("libsched.so") -clib.ert_load("libanalysis.so") -lib = clib.ert_load("libenkf.so") - diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/local_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/local_config.py index 682c03823c..3024634f33 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/local_config.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/local_config.py @@ -12,45 +12,38 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB + +from ert.util import StringList + + +class LocalConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -from ert.util.stringlist import StringList -class LocalConfig(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property def get_config_files(self): - config_files = StringList(c_ptr = cfunc.get_config_files(self), parent = self) - return config_files + """ @rtype: StringList """ + return LocalConfig.cNamespace().get_config_files(self).setParent(self) def clear_config_files(self): - cfunc.clear_config_files(self) + LocalConfig.cNamespace().clear_config_files(self) - def add_config_file(self, file): - cfunc.add_config_file(self, file) -################################################################## + def add_config_file(self, filename): + LocalConfig.cNamespace().add_config_file(self, filename) -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "local_config" , LocalConfig ) + def free(self): + LocalConfig.cNamespace().free(self) -cfunc = CWrapperNameSpace("local_config") -################################################################## -################################################################## +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("local_config", LocalConfig) +cwrapper.registerType("local_config_obj", LocalConfig.createPythonObject) +cwrapper.registerType("local_config_ref", LocalConfig.createCReference) -cfunc.free = cwrapper.prototype("void local_config_free( local_config )") -cfunc.get_config_files = cwrapper.prototype("c_void_p local_config_get_config_files( local_config )") -cfunc.clear_config_files = cwrapper.prototype("void local_config_clear_config_files( local_config )") -cfunc.add_config_file = cwrapper.prototype("void local_config_add_config_file( local_config , char*)") +LocalConfig.cNamespace().free = cwrapper.prototype("void local_config_free( local_config )") +LocalConfig.cNamespace().get_config_files = cwrapper.prototype("stringlist_ref local_config_get_config_files( local_config )") +LocalConfig.cNamespace().clear_config_files = cwrapper.prototype("void local_config_clear_config_files( local_config )") +LocalConfig.cNamespace().add_config_file = cwrapper.prototype("void local_config_add_config_file( local_config , char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/model_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/model_config.py index 4c9ce0a684..e08f3dfd04 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/model_config.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/model_config.py @@ -12,81 +12,94 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. - -import ctypes +# for more details. +from ert.cwrap import CWrapper, BaseCClass +from ert.ecl import EclSum +from ert.enkf import ENKF_LIB +from ert.sched import HistorySourceEnum, SchedFile from ert.job_queue import ForwardModel -from ert.sched import HistoryType -from libenkf import * -from enkf_enum import * -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace -class ModelConfig(CClass): - def __init__(self, c_ptr, parent=None): - if parent: - self.init_cref(c_ptr, parent) - else: - self.init_cobj(c_ptr, cfunc.free) +class ModelConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - @property def get_enkf_sched_file(self): - return cfunc.get_enkf_sched_file(self) + """ @rtype: str """ + return ModelConfig.cNamespace().get_enkf_sched_file(self) - def set_enkf_sched_file(self, file): - cfunc.get_enkf_sched_file(self, file) + def set_enkf_sched_file(self, filename): + ModelConfig.cNamespace().get_enkf_sched_file(self, filename) + + def hasHistory(self): + return ModelConfig.cNamespace().has_history(self) - @property def get_history_source(self): - return HistoryType(c_ptr=cfunc.get_history_source(self), parent=self) + """ @rtype: HistorySourceEnum """ + return ModelConfig.cNamespace().get_history_source(self) def set_history_source(self, history_source, sched_file, refcase): - return cfunc.select_history(self, history_source, sched_file, refcase) + """ + @type history_source: HistorySourceEnum + @type sched_file: SchedFile + @type refcase: EclSum + @rtype: bool + """ + assert isinstance(history_source, HistorySourceEnum) + assert isinstance(sched_file, SchedFile) + assert isinstance(refcase, EclSum) + return ModelConfig.cNamespace().select_history(self, history_source, sched_file, refcase) - @property def get_max_internal_submit(self): - return cfunc.get_max_internal_submit(self) + """ @rtype: int """ + return ModelConfig.cNamespace().get_max_internal_submit(self) - def set_max_internal_submit(self, max): - cfunc.get_max_internal_submit(self, max) + def set_max_internal_submit(self, max_value): + ModelConfig.cNamespace().get_max_internal_submit(self, max_value) - @property def get_forward_model(self): - ford_model = ForwardModel(c_ptr=cfunc.get_forward_model(self), parent=self) - return ford_model + """ @rtype: ForwardModel """ + return ModelConfig.cNamespace().get_forward_model(self).setParent(self) - @property def get_case_table_file(self): - return cfunc.get_case_table_file(self) + """ @rtype: str """ + return ModelConfig.cNamespace().get_case_table_file(self) - @property def get_runpath_as_char(self): - return cfunc.get_runpath_as_char(self) + """ @rtype: str """ + return ModelConfig.cNamespace().get_runpath_as_char(self) def select_runpath(self, path_key): - return cfunc.select_runpath(self, path_key) + """ @rtype: bool """ + return ModelConfig.cNamespace().select_runpath(self, path_key) + + def free(self): + ModelConfig.cNamespace().free(self) ################################################################## -cwrapper = CWrapper(libenkf.lib) +cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("model_config", ModelConfig) +cwrapper.registerType("model_config_obj", ModelConfig.createPythonObject) +cwrapper.registerType("model_config_ref", ModelConfig.createCReference) -cfunc = CWrapperNameSpace("model_config") ################################################################## ################################################################## -cfunc.free = cwrapper.prototype("void model_config_free( model_config )") -cfunc.get_enkf_sched_file = cwrapper.prototype("char* model_config_get_enkf_sched_file( model_config )") -cfunc.set_enkf_sched_file = cwrapper.prototype("void model_config_set_enkf_sched_file( model_config, char*)") -cfunc.get_history_source = cwrapper.prototype("c_void_p model_config_get_history_source(model_config)") -cfunc.select_history = cwrapper.prototype( - "bool model_config_select_history(model_config, history_type, c_void_p, ecl_sum)") -cfunc.get_forward_model = cwrapper.prototype("c_void_p model_config_get_forward_model(model_config)") -cfunc.get_max_internal_submit = cwrapper.prototype("int model_config_get_max_internal_submit(model_config)") -cfunc.set_max_internal_submit = cwrapper.prototype("void model_config_set_max_internal_submit(model_config, int)") -cfunc.get_case_table_file = cwrapper.prototype("char* model_config_get_case_table_file(model_config)") -cfunc.get_runpath_as_char = cwrapper.prototype("char* model_config_get_runpath_as_char(model_config)") -cfunc.select_runpath = cwrapper.prototype("void model_config_select_runpath(model_config, char*)") - +ModelConfig.cNamespace().free = cwrapper.prototype("void model_config_free( model_config )") +ModelConfig.cNamespace().get_enkf_sched_file = cwrapper.prototype("char* model_config_get_enkf_sched_file( model_config )") +ModelConfig.cNamespace().set_enkf_sched_file = cwrapper.prototype("void model_config_set_enkf_sched_file( model_config, char*)") +ModelConfig.cNamespace().get_forward_model = cwrapper.prototype("forward_model_ref model_config_get_forward_model(model_config)") +ModelConfig.cNamespace().get_max_internal_submit = cwrapper.prototype("int model_config_get_max_internal_submit(model_config)") +ModelConfig.cNamespace().set_max_internal_submit = cwrapper.prototype("void model_config_set_max_internal_submit(model_config, int)") +ModelConfig.cNamespace().get_case_table_file = cwrapper.prototype("char* model_config_get_case_table_file(model_config)") +ModelConfig.cNamespace().get_runpath_as_char = cwrapper.prototype("char* model_config_get_runpath_as_char(model_config)") +ModelConfig.cNamespace().select_runpath = cwrapper.prototype("bool model_config_select_runpath(model_config, char*)") + +ModelConfig.cNamespace().get_history = cwrapper.prototype("history_ref model_config_get_history(model_config)") +ModelConfig.cNamespace().get_history_source = cwrapper.prototype("history_source_enum model_config_get_history_source(model_config)") +ModelConfig.cNamespace().select_history = cwrapper.prototype("bool model_config_select_history(model_config, history_source_enum, sched_file, ecl_sum)") +ModelConfig.cNamespace().has_history = cwrapper.prototype("bool model_config_has_history(model_config)") + diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/obs_vector.py b/ThirdParty/Ert/devel/python/python/ert/enkf/obs_vector.py deleted file mode 100644 index 4bed9d61ac..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/obs_vector.py +++ /dev/null @@ -1,60 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'obs_vector.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import libenkf -class ObsVector(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_state_kw(self): - return cfunc.get_state_kw(self) - - def iget_node(self, index): - cfunc.iget_node(self,index) - - @property - def get_num_active(self): - return cfunc.get_num_active(self) - - @property - def iget_active(self, index): - return cfunc.iget_active(self, index) -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "obs_vector" , ObsVector ) - -# 3. Installing the c-functions used to manipulate ecl_kw instances. -# These functions are used when implementing the EclKW class, not -# used outside this scope. -cfunc = CWrapperNameSpace("obs_vector") - - -cfunc.free = cwrapper.prototype("void obs_vector_free( obs_vector )") -cfunc.get_state_kw = cwrapper.prototype("char* obs_vector_get_state_kw( obs_vector )") -cfunc.iget_node = cwrapper.prototype("void obs_vector_iget_node( obs_vector, int)") -cfunc.get_num_active = cwrapper.prototype("int obs_vector_get_num_active( obs_vector )") -cfunc.iget_active = cwrapper.prototype("bool obs_vector_iget_active( obs_vector, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/plot_conf.py b/ThirdParty/Ert/devel/python/python/ert/enkf/plot_conf.py deleted file mode 100644 index a3f652ad49..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/plot_conf.py +++ /dev/null @@ -1,103 +0,0 @@ -# Copyright (C) 2012 Statoil ASA, Norway. -# -# The file 'plot_conf.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.tvector import * -from enkf_enum import * -import ert.enkf.libenkf - -class PlotConf(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_path(self): - return cfunc.get_path(self) - - def set_path(self, path): - cfunc.set_path(self, path) - - @property - def get_driver(self): - return cfunc.get_driver(self) - - def set_driver(self, driver): - cfunc.set_driver(self, driver) - - @property - def get_errorbar_max(self): - return cfunc.get_errorbar_max(self) - - def set_errorbar_max(self, max): - cfunc.set_errorbar_max(self, max) - - @property - def get_width(self): - return cfunc.get_width(self) - - def set_width(self, value): - cfunc.set_width(self, value) - - @property - def get_height(self): - return cfunc.get_height(self) - - def set_height(self, value): - cfunc.set_height(self, value) - - @property - def get_viewer(self): - return cfunc.get_viewer(self) - - def set_viewer(self, value): - cfunc.set_viewer(self, value) - - @property - def get_image_type(self): - return cfunc.get_image_type(self) - - def set_image_type(self, value): - cfunc.set_image_type(self, value) -################################################################## - -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "plot_conf" , PlotConf ) - -cfunc = CWrapperNameSpace("plot_conf") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void plot_config_free( plot_conf )") -cfunc.get_path = cwrapper.prototype("char* plot_config_get_path(plot_conf)") -cfunc.set_path = cwrapper.prototype("void plot_config_set_path(plot_conf, char*)") -cfunc.get_driver = cwrapper.prototype("char* plot_config_get_driver(plot_conf)") -cfunc.set_driver = cwrapper.prototype("void plot_config_set_driver(plot_conf, char*)") -cfunc.get_errorbar_max = cwrapper.prototype("int plot_config_get_errorbar_max(plot_conf)") -cfunc.set_errorbar_max = cwrapper.prototype("void plot_config_set_errorbar_max(plot_conf, int)") -cfunc.get_width = cwrapper.prototype("int plot_config_get_width(plot_conf)") -cfunc.set_width = cwrapper.prototype("void plot_config_set_width(plot_conf, int)") -cfunc.get_height = cwrapper.prototype("int plot_config_get_height(plot_conf)") -cfunc.set_height = cwrapper.prototype("void plot_config_set_height(plot_conf, int)") -cfunc.get_viewer = cwrapper.prototype("char* plot_config_get_viewer(plot_conf)") -cfunc.set_viewer = cwrapper.prototype("void plot_config_set_viewer(plot_conf, char*)") -cfunc.get_image_type = cwrapper.prototype("char* plot_config_get_image_type(plot_conf)") -cfunc.set_image_type = cwrapper.prototype("void plot_config_set_image_type(plot_conf, char*)") - diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/plot_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/plot_config.py new file mode 100644 index 0000000000..2508051d1c --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/plot_config.py @@ -0,0 +1,98 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'plot_config.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB + + +class PlotConfig(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def get_path(self): + """ @rtype: str """ + return PlotConfig.cNamespace().get_path(self) + + def set_path(self, path): + PlotConfig.cNamespace().set_path(self, path) + + def get_driver(self): + """ @rtype: str """ + return PlotConfig.cNamespace().get_driver(self) + + def set_driver(self, driver): + PlotConfig.cNamespace().set_driver(self, driver) + + def get_errorbar_max(self): + """ @rtype: int """ + return PlotConfig.cNamespace().get_errorbar_max(self) + + def set_errorbar_max(self, max_value): + PlotConfig.cNamespace().set_errorbar_max(self, max_value) + + def get_width(self): + """ @rtype: int """ + return PlotConfig.cNamespace().get_width(self) + + def set_width(self, value): + PlotConfig.cNamespace().set_width(self, value) + + def get_height(self): + """ @rtype: int """ + return PlotConfig.cNamespace().get_height(self) + + def set_height(self, value): + PlotConfig.cNamespace().set_height(self, value) + + def get_viewer(self): + """ @rtype: str """ + return PlotConfig.cNamespace().get_viewer(self) + + def set_viewer(self, value): + PlotConfig.cNamespace().set_viewer(self, value) + + def get_image_type(self): + """ @rtype: str """ + return PlotConfig.cNamespace().get_image_type(self) + + def set_image_type(self, value): + PlotConfig.cNamespace().set_image_type(self, value) + + def free(self): + PlotConfig.cNamespace().free(self) + + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("plot_config", PlotConfig) +cwrapper.registerType("plot_config_obj", PlotConfig.createPythonObject) +cwrapper.registerType("plot_config_ref", PlotConfig.createCReference) + +PlotConfig.cNamespace().free = cwrapper.prototype("void plot_config_free( plot_config )") + +PlotConfig.cNamespace().get_path = cwrapper.prototype("char* plot_config_get_path(plot_config)") +PlotConfig.cNamespace().set_path = cwrapper.prototype("void plot_config_set_path(plot_config, char*)") +PlotConfig.cNamespace().get_driver = cwrapper.prototype("char* plot_config_get_driver(plot_config)") +PlotConfig.cNamespace().set_driver = cwrapper.prototype("void plot_config_set_driver(plot_config, char*)") +PlotConfig.cNamespace().get_errorbar_max = cwrapper.prototype("int plot_config_get_errorbar_max(plot_config)") +PlotConfig.cNamespace().set_errorbar_max = cwrapper.prototype("void plot_config_set_errorbar_max(plot_config, int)") +PlotConfig.cNamespace().get_width = cwrapper.prototype("int plot_config_get_width(plot_config)") +PlotConfig.cNamespace().set_width = cwrapper.prototype("void plot_config_set_width(plot_config, int)") +PlotConfig.cNamespace().get_height = cwrapper.prototype("int plot_config_get_height(plot_config)") +PlotConfig.cNamespace().set_height = cwrapper.prototype("void plot_config_set_height(plot_config, int)") +PlotConfig.cNamespace().get_viewer = cwrapper.prototype("char* plot_config_get_viewer(plot_config)") +PlotConfig.cNamespace().set_viewer = cwrapper.prototype("void plot_config_set_viewer(plot_config, char*)") +PlotConfig.cNamespace().get_image_type = cwrapper.prototype("char* plot_config_get_image_type(plot_config)") +PlotConfig.cNamespace().set_image_type = cwrapper.prototype("void plot_config_set_image_type(plot_config, char*)") + diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/site_config.py b/ThirdParty/Ert/devel/python/python/ert/enkf/site_config.py index 6c121b85b1..75d4f9c430 100644 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/site_config.py +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/site_config.py @@ -12,184 +12,177 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. - -import ctypes -from enkf_enum import * -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace -from ert.job_queue import ExtJoblist, JobQueue -from ert.util import StringList -import libenkf -from ert.enkf.libenkf import * +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB +from ert.job_queue import JobQueue, ExtJoblist +from ert.util import StringList, Hash - - -class SiteConfig(CClass): +class SiteConfig(BaseCClass): - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - @property def get_queue_name(self): - return cfunc.get_queue_name( self ) + """ @rtype: str """ + return SiteConfig.cNamespace().get_queue_name( self ) def set_job_queue(self, queue): - cfunc.set_job_queue( self , queue) + SiteConfig.cNamespace().set_job_queue( self , queue) - @property def get_lsf_queue(self): - return cfunc.get_lsf_queue( self ) + """ @rtype: str """ + return SiteConfig.cNamespace().get_lsf_queue( self ) def set_lsf_queue(self, queue): - cfunc.set_lsf_queue( self , queue) + SiteConfig.cNamespace().set_lsf_queue( self , queue) - @property def get_max_running_lsf(self): - return cfunc.get_max_running_lsf( self ) + """ @rtype: int """ + return SiteConfig.cNamespace().get_max_running_lsf( self ) def set_max_running_lsf(self, max_running): - cfunc.set_max_running_lsf( self , max_running) + SiteConfig.cNamespace().set_max_running_lsf( self , max_running) - @property def get_lsf_request(self): - return cfunc.get_lsf_request( self ) + """ @rtype: str """ + return SiteConfig.cNamespace().get_lsf_request( self ) def set_lsf_request(self, lsf_request): - cfunc.set_lsf_request( self , lsf_request) + SiteConfig.cNamespace().set_lsf_request( self , lsf_request) def clear_rsh_host_list(self): - cfunc.set_rsh_host_list( self ) + SiteConfig.cNamespace().clear_rsh_host_list( self ) - @property def get_rsh_command(self): - return cfunc.get_rsh_command( self ) + """ @rtype: str """ + return SiteConfig.cNamespace().get_rsh_command( self ) def set_rsh_command(self, rsh_command): - cfunc.set_rsh_command( self , rsh_command) + SiteConfig.cNamespace().set_rsh_command( self , rsh_command) - @property def get_max_running_rsh(self): - return cfunc.get_max_running_rsh( self ) + """ @rtype: int """ + return SiteConfig.cNamespace().get_max_running_rsh( self ) def set_max_running_rsh(self, max_running): - cfunc.set_max_running_rsh( self , max_running) + SiteConfig.cNamespace().set_max_running_rsh( self , max_running) - @property def get_max_running_local(self): - return cfunc.get_max_running_local( self ) + """ @rtype: int """ + return SiteConfig.cNamespace().get_max_running_local( self ) def set_max_running_local(self, max_running): - cfunc.set_max_running_local( self , max_running) + SiteConfig.cNamespace().set_max_running_local( self , max_running) - @property def get_job_script(self): - return cfunc.get_job_script( self ) + """ @rtype: str """ + return SiteConfig.cNamespace().get_job_script( self ) def set_job_script(self, job_script): - cfunc.set_job_script( self , job_script) + SiteConfig.cNamespace().set_job_script( self , job_script) - @property def get_env_hash(self): - return cfunc.get_env_hash( self ) + """ @rtype: StringHash """ + return SiteConfig.cNamespace().get_env_hash( self ) def setenv(self, var, value): - cfunc.setenv( self , var, value) + SiteConfig.cNamespace().setenv( self , var, value) def clear_env(self): - cfunc.clear_env( self ) + SiteConfig.cNamespace().clear_env( self ) - @property def get_path_variables(self): - return StringList(c_ptr = cfunc.get_path_variables( self ), parent = self) + """ @rtype: StringList """ + return SiteConfig.cNamespace().get_path_variables(self).setParent(self) - @property def get_path_values(self): - return StringList(c_ptr = cfunc.get_path_values( self ), parent = self) + """ @rtype: StringList """ + return SiteConfig.cNamespace().get_path_values(self).setParent(self) def clear_pathvar(self): - cfunc.clear_pathvar( self ) + SiteConfig.cNamespace().clear_pathvar( self ) def update_pathvar(self, pathvar, value): - cfunc.update_pathvar( self ) + SiteConfig.cNamespace().update_pathvar( self, pathvar, value) - @property def get_installed_jobs(self): - installed_jobs = ExtJoblist( cfunc.get_installed_jobs( self ), parent = self) - return installed_jobs + """ @rtype: ExtJoblist """ + return SiteConfig.cNamespace().get_installed_jobs(self).setParent(self) - @property def get_max_submit(self): - return cfunc.get_max_submit( self ) + """ @rtype: int """ + return SiteConfig.cNamespace().get_max_submit( self ) - def set_max_submit(self, max): - cfunc.set_max_submit( self , max) + def set_max_submit(self, max_value): + SiteConfig.cNamespace().set_max_submit( self , max_value) - @property def get_license_root_path(self): - return cfunc.get_license_root_path( self ) + """ @rtype: str """ + return SiteConfig.cNamespace().get_license_root_path( self ) def set_license_root_pathmax_submit(self, path): - cfunc.set_license_root_path( self , path) + SiteConfig.cNamespace().set_license_root_path( self , path) - @property def queue_is_running(self): - return cfunc.queue_is_running( self ) + """ @rtype: bool """ + return SiteConfig.cNamespace().queue_is_running( self ) def get_job_queue(self): - return JobQueue( c_ptr = cfunc.get_job_queue(self), parent = self) + """ @rtype: JobQueue """ + return SiteConfig.cNamespace().get_job_queue(self).setParent(self) - @property def get_rsh_host_list(self): - return cfunc.get_rsh_host_list(self) + """ @rtype: IntegerHash """ + host_list = SiteConfig.cNamespace().get_rsh_host_list(self) + return host_list def add_rsh_host(self, host, max_running): - cfunc.add_rsh_host(self, host, max_running) -################################################################## + SiteConfig.cNamespace().add_rsh_host(self, host, max_running) -cwrapper = CWrapper( libenkf.lib ) + def free(self): + SiteConfig.cNamespace().free(self) + +cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType( "site_config" , SiteConfig ) +cwrapper.registerType( "site_config_obj" , SiteConfig.createPythonObject) +cwrapper.registerType( "site_config_ref" , SiteConfig.createCReference) -cfunc = CWrapperNameSpace("site_config") -################################################################## -################################################################## +SiteConfig.cNamespace().free = cwrapper.prototype("void site_config_free( site_config )") +SiteConfig.cNamespace().get_queue_name = cwrapper.prototype("char* site_config_get_queue_name(site_config)") +SiteConfig.cNamespace().set_job_queue = cwrapper.prototype("void site_config_set_job_queue(site_config, char*)") +SiteConfig.cNamespace().get_lsf_queue = cwrapper.prototype("char* site_config_get_lsf_queue(site_config)") +SiteConfig.cNamespace().set_lsf_queue = cwrapper.prototype("void site_config_set_lsf_queue(site_config, char*)") +SiteConfig.cNamespace().get_max_running_lsf = cwrapper.prototype("int site_config_get_max_running_lsf(site_config)") +SiteConfig.cNamespace().set_max_running_lsf = cwrapper.prototype("void site_config_set_max_running_lsf(site_config, int)") +SiteConfig.cNamespace().get_lsf_request = cwrapper.prototype("char* site_config_get_lsf_request(site_config)") +SiteConfig.cNamespace().set_lsf_request = cwrapper.prototype("void site_config_set_lsf_request(site_config, char*)") -cfunc.free = cwrapper.prototype("void site_config_free( site_config )") -cfunc.get_queue_name = cwrapper.prototype("char* site_config_get_queue_name(site_config)") -cfunc.set_job_queue = cwrapper.prototype("void site_config_set_job_queue(site_config, char*)") -cfunc.get_lsf_queue = cwrapper.prototype("char* site_config_get_lsf_queue(site_config)") -cfunc.set_lsf_queue = cwrapper.prototype("void site_config_set_lsf_queue(site_config, char*)") -cfunc.get_max_running_lsf = cwrapper.prototype("int site_config_get_max_running_lsf(site_config)") -cfunc.set_max_running_lsf = cwrapper.prototype("void site_config_set_max_running_lsf(site_config, int)") -cfunc.get_lsf_request = cwrapper.prototype("char* site_config_get_lsf_request(site_config)") -cfunc.set_lsf_request = cwrapper.prototype("void site_config_set_lsf_request(site_config, char*)") -cfunc.get_rsh_command = cwrapper.prototype("char* site_config_get_rsh_command(site_config)") -cfunc.set_rsh_command = cwrapper.prototype("void site_config_set_rsh_command(site_config, char*)") -cfunc.get_max_running_rsh = cwrapper.prototype("int site_config_get_max_running_rsh(site_config)") -cfunc.set_max_running_rsh = cwrapper.prototype("void site_config_set_max_running_rsh(site_config, int)") -cfunc.get_rsh_host_list = cwrapper.prototype("c_void_p site_config_get_rsh_host_list(site_config)") -cfunc.clear_rsh_host_list = cwrapper.prototype("void site_config_clear_rsh_host_list(site_config)") -cfunc.add_rsh_host = cwrapper.prototype("void site_config_add_rsh_host(site_config, char*, int)") -cfunc.get_max_running_local = cwrapper.prototype("int site_config_get_max_running_local(site_config)") -cfunc.set_max_running_local = cwrapper.prototype("void site_config_set_max_running_local(site_config, int)") -cfunc.get_installed_jobs = cwrapper.prototype("c_void_p site_config_get_installed_jobs(site_config)") -cfunc.get_max_submit = cwrapper.prototype("int site_config_get_max_submit(site_config)") -cfunc.set_max_submit = cwrapper.prototype("void site_config_set_max_submit(site_config, int)") -cfunc.get_license_root_path = cwrapper.prototype("char* site_config_get_license_root_path(site_config)") -cfunc.set_license_root_path = cwrapper.prototype("void site_config_set_license_root_path(site_config, char*)") -cfunc.get_job_script = cwrapper.prototype("char* site_config_get_job_script(site_config)") -cfunc.set_job_script = cwrapper.prototype("void site_config_set_job_script(site_config, char*)") -cfunc.get_env_hash = cwrapper.prototype("c_void_p site_config_get_env_hash(site_config)") -cfunc.clear_env = cwrapper.prototype("void site_config_clear_env(site_config)") -cfunc.setenv = cwrapper.prototype("void site_config_setenv(site_config, char*, char*)") -cfunc.get_path_variables = cwrapper.prototype("c_void_p site_config_get_path_variables(site_config)") -cfunc.get_path_values = cwrapper.prototype("c_void_p site_config_get_path_values(site_config)") -cfunc.clear_pathvar = cwrapper.prototype("void site_config_clear_pathvar(site_config)") -cfunc.update_pathvar = cwrapper.prototype("void site_config_update_pathvar(site_config, char*, char*)") -cfunc.get_job_queue = cwrapper.prototype("c_void_p site_config_get_job_queue(site_config)") -cfunc.queue_is_running = cwrapper.prototype("bool site_config_queue_is_running(site_config)") +SiteConfig.cNamespace().get_rsh_command = cwrapper.prototype("char* site_config_get_rsh_command(site_config)") +SiteConfig.cNamespace().set_rsh_command = cwrapper.prototype("void site_config_set_rsh_command(site_config, char*)") +SiteConfig.cNamespace().get_max_running_rsh = cwrapper.prototype("int site_config_get_max_running_rsh(site_config)") +SiteConfig.cNamespace().set_max_running_rsh = cwrapper.prototype("void site_config_set_max_running_rsh(site_config, int)") +SiteConfig.cNamespace().get_rsh_host_list = cwrapper.prototype("integer_hash_ref site_config_get_rsh_host_list(site_config)") +SiteConfig.cNamespace().clear_rsh_host_list = cwrapper.prototype("void site_config_clear_rsh_host_list(site_config)") +SiteConfig.cNamespace().add_rsh_host = cwrapper.prototype("void site_config_add_rsh_host(site_config, char*, int)") + +SiteConfig.cNamespace().get_max_running_local = cwrapper.prototype("int site_config_get_max_running_local(site_config)") +SiteConfig.cNamespace().set_max_running_local = cwrapper.prototype("void site_config_set_max_running_local(site_config, int)") +SiteConfig.cNamespace().get_installed_jobs = cwrapper.prototype("ext_joblist_ref site_config_get_installed_jobs(site_config)") +SiteConfig.cNamespace().get_max_submit = cwrapper.prototype("int site_config_get_max_submit(site_config)") +SiteConfig.cNamespace().set_max_submit = cwrapper.prototype("void site_config_set_max_submit(site_config, int)") +SiteConfig.cNamespace().get_license_root_path = cwrapper.prototype("char* site_config_get_license_root_path(site_config)") +SiteConfig.cNamespace().set_license_root_path = cwrapper.prototype("void site_config_set_license_root_path(site_config, char*)") +SiteConfig.cNamespace().get_job_script = cwrapper.prototype("char* site_config_get_job_script(site_config)") +SiteConfig.cNamespace().set_job_script = cwrapper.prototype("void site_config_set_job_script(site_config, char*)") +SiteConfig.cNamespace().get_env_hash = cwrapper.prototype("string_hash_ref site_config_get_env_hash(site_config)") +SiteConfig.cNamespace().clear_env = cwrapper.prototype("void site_config_clear_env(site_config)") +SiteConfig.cNamespace().setenv = cwrapper.prototype("void site_config_setenv(site_config, char*, char*)") +SiteConfig.cNamespace().get_path_variables = cwrapper.prototype("stringlist_ref site_config_get_path_variables(site_config)") +SiteConfig.cNamespace().get_path_values = cwrapper.prototype("stringlist_ref site_config_get_path_values(site_config)") +SiteConfig.cNamespace().clear_pathvar = cwrapper.prototype("void site_config_clear_pathvar(site_config)") +SiteConfig.cNamespace().update_pathvar = cwrapper.prototype("void site_config_update_pathvar(site_config, char*, char*)") +SiteConfig.cNamespace().get_job_queue = cwrapper.prototype("job_queue_ref site_config_get_job_queue(site_config)") +SiteConfig.cNamespace().queue_is_running = cwrapper.prototype("bool site_config_queue_is_running(site_config)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/time_map.py b/ThirdParty/Ert/devel/python/python/ert/enkf/time_map.py deleted file mode 100644 index 086ca8e6b9..0000000000 --- a/ThirdParty/Ert/devel/python/python/ert/enkf/time_map.py +++ /dev/null @@ -1,53 +0,0 @@ -# Copyright (C) 2013 Statoil ASA, Norway. -# -# The file 'time_map.py' is part of ERT - Ensemble based Reservoir Tool. -# -# ERT is free software: you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation, either version 3 of the License, or -# (at your option) any later version. -# -# ERT is distributed in the hope that it will be useful, but WITHOUT ANY -# WARRANTY; without even the implied warranty of MERCHANTABILITY or -# FITNESS FOR A PARTICULAR PURPOSE. -# -# See the GNU General Public License at -# for more details. - -import ctypes -from ert.cwrap.cwrap import * -from ert.cwrap.cclass import CClass -from ert.util.ctime import ctime -from ert.util.tvector import * -from enkf_enum import * -import libenkf -from ert.enkf.libenkf import * -from ert.ert.erttypes import time_t - -class TimeMap(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def iget_sim_days(self, step): - return cfunc.iget_sim_days(self,step) - - def iget(self,step): - return cfunc.iget(self,step) - -################################################################## -cwrapper = CWrapper( libenkf.lib ) -cwrapper.registerType( "time_map" , TimeMap ) - -cfunc = CWrapperNameSpace("time_map") - -################################################################## -################################################################## - -cfunc.free = cwrapper.prototype("void time_map_free( time_map )") -cfunc.iget_sim_days = cwrapper.prototype("double time_map_iget_sim_days(time_map, int)") -cfunc.iget = cwrapper.prototype("int time_map_iget(time_map, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/util/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/enkf/util/CMakeLists.txt new file mode 100644 index 0000000000..4992d84034 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/util/CMakeLists.txt @@ -0,0 +1,8 @@ +set(PYTHON_SOURCES + __init__.py + obs_vector.py + time_map.py +) + +add_python_package("Python ert.enkf.util" ${PYTHON_INSTALL_PREFIX}/ert/enkf/util "${PYTHON_SOURCES}" True) + diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/util/__init__.py b/ThirdParty/Ert/devel/python/python/ert/enkf/util/__init__.py new file mode 100644 index 0000000000..cd49c677c2 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/util/__init__.py @@ -0,0 +1,4 @@ +import ert.enkf + +from .obs_vector import ObsVector +from .time_map import TimeMap \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/util/obs_vector.py b/ThirdParty/Ert/devel/python/python/ert/enkf/util/obs_vector.py new file mode 100644 index 0000000000..8d1b28cb66 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/util/obs_vector.py @@ -0,0 +1,56 @@ +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'obs_vector.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import BaseCClass, CWrapper +from ert.enkf import ENKF_LIB + + +class ObsVector(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def get_state_kw(self): + """ @rtype: str """ + return ObsVector.cNamespace().get_state_kw(self) + + def iget_node(self, index): + ObsVector.cNamespace().iget_node(self, index) #warn: should return something! + + def get_num_active(self): + """ @rtype: int """ + return ObsVector.cNamespace().get_num_active(self) + + def iget_active(self, index): + """ @rtype: bool """ + return ObsVector.cNamespace().iget_active(self, index) + + def free(self): + ObsVector.cNamespace().free(self) + + +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("obs_vector", ObsVector) +cwrapper.registerType("obs_vector_obj", ObsVector.createPythonObject) +cwrapper.registerType("obs_vector_ref", ObsVector.createCReference) + +# 3. Installing the c-functions used to manipulate ecl_kw instances. +# These functions are used when implementing the EclKW class, not +# used outside this scope. + +ObsVector.cNamespace().free = cwrapper.prototype("void obs_vector_free( obs_vector )") +ObsVector.cNamespace().get_state_kw = cwrapper.prototype("char* obs_vector_get_state_kw( obs_vector )") +ObsVector.cNamespace().iget_node = cwrapper.prototype("c_void_p obs_vector_iget_node( obs_vector, int)") +ObsVector.cNamespace().get_num_active = cwrapper.prototype("int obs_vector_get_num_active( obs_vector )") +ObsVector.cNamespace().iget_active = cwrapper.prototype("bool obs_vector_iget_active( obs_vector, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/enkf/util/time_map.py b/ThirdParty/Ert/devel/python/python/ert/enkf/util/time_map.py new file mode 100644 index 0000000000..9e2ea3a966 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/enkf/util/time_map.py @@ -0,0 +1,45 @@ +# Copyright (C) 2013 Statoil ASA, Norway. +# +# The file 'time_map.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. +from ert.cwrap import CWrapper, BaseCClass +from ert.enkf import ENKF_LIB + + +class TimeMap(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def iget_sim_days(self, step): + return TimeMap.cNamespace().iget_sim_days(self, step) + + def iget(self, step): + return TimeMap.cNamespace().iget(self, step) + + def free(self): + TimeMap.cNamespace().free(self) + +################################################################## +cwrapper = CWrapper(ENKF_LIB) +cwrapper.registerType("time_map", TimeMap) +cwrapper.registerType("time_map_obj", TimeMap.createPythonObject) +cwrapper.registerType("time_map_ref", TimeMap.createCReference) + + +################################################################## +################################################################## + +TimeMap.cNamespace().free = cwrapper.prototype("void time_map_free( time_map )") +TimeMap.cNamespace().iget_sim_days = cwrapper.prototype("double time_map_iget_sim_days(time_map, int)") +TimeMap.cNamespace().iget = cwrapper.prototype("int time_map_iget(time_map, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_job.py b/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_job.py index 7f8f4bd396..4123051027 100644 --- a/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_job.py +++ b/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_job.py @@ -13,142 +13,128 @@ # # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import BaseCClass, CWrapper from ert.job_queue import JOB_QUEUE_LIB -class ExtJob(CClass): - def __init__(self, c_ptr, parent=None): - if parent: - self.init_cref(c_ptr, parent) +class ExtJob(BaseCClass): + def __init__(self, name, root_path, private, config_file = None): + if config_file is None: + c_ptr = ExtJob.cNamespace().alloc(name, root_path, private) + super(ExtJob, self).__init__(c_ptr) else: - self.init_cobj(c_ptr, cfunc.free) + c_ptr = ExtJob.cNamespace().fscanf_alloc(name, root_path, private, config_file) + super(ExtJob, self).__init__(c_ptr) + - @property def get_private_args_as_string(self): - return cfunc.get_private_args_as_string(self) + return ExtJob.cNamespace().get_private_args_as_string(self) def set_private_args_as_string(self, args): - cfunc.set_private_args_as_string(self, args) + ExtJob.cNamespace().set_private_args_as_string(self, args) - @property def get_help_text(self): - return cfunc.get_help_text(self) + return ExtJob.cNamespace().get_help_text(self) - @property def is_private(self): - return cfunc.is_private(self) + return ExtJob.cNamespace().is_private(self) - @property def get_config_file(self): - return cfunc.get_config_file(self) + return ExtJob.cNamespace().get_config_file(self) def set_config_file(self, config_file): - cfunc.set_config_file(self, config_file) + ExtJob.cNamespace().set_config_file(self, config_file) - @property def get_stdin_file(self): - return cfunc.get_stdin_file(self) + return ExtJob.cNamespace().get_stdin_file(self) def set_stdin_file(self, filename): - cfunc.set_stdin_file(self, filename) + ExtJob.cNamespace().set_stdin_file(self, filename) - @property def get_stdout_file(self): - return cfunc.get_stdout_file(self) + return ExtJob.cNamespace().get_stdout_file(self) def set_stdout_file(self, filename): - cfunc.set_stdout_file(self, filename) + ExtJob.cNamespace().set_stdout_file(self, filename) - @property def get_stderr_file(self): - return cfunc.get_stderr_file(self) + return ExtJob.cNamespace().get_stderr_file(self) def set_stderr_file(self, filename): - cfunc.set_stderr_file(self, filename) + ExtJob.cNamespace().set_stderr_file(self, filename) - @property def get_target_file(self): - return cfunc.get_target_file(self) + return ExtJob.cNamespace().get_target_file(self) def set_target_file(self, filename): - cfunc.set_target_file(self, filename) + ExtJob.cNamespace().set_target_file(self, filename) - @property def get_executable(self): - return cfunc.get_executable(self) + return ExtJob.cNamespace().get_executable(self) def set_executable(self, executable): - cfunc.set_executable(self, executable) + ExtJob.cNamespace().set_executable(self, executable) - @property def get_max_running(self): - return cfunc.get_max_running(self) + return ExtJob.cNamespace().get_max_running(self) def set_max_running(self, max_running): - cfunc.set_max_running(self, max_running) + ExtJob.cNamespace().set_max_running(self, max_running) - @property def get_max_running_minutes(self): - return cfunc.get_max_running_minutes(self) + return ExtJob.cNamespace().get_max_running_minutes(self) def set_max_running_minutes(self, min_value): - cfunc.set_max_running_minutes(self, min_value) + ExtJob.cNamespace().set_max_running_minutes(self, min_value) - @property def get_environment(self): - return cfunc.get_environment(self) + return ExtJob.cNamespace().get_environment(self) #warn: fix return type def set_environment(self, key, value): - cfunc.set_environment(self, key, value) + ExtJob.cNamespace().set_environment(self, key, value) def clear_environment(self): - cfunc.clear_environment(self) + ExtJob.cNamespace().clear_environment(self) def save(self): - cfunc.save(self) + ExtJob.cNamespace().save(self) - @staticmethod - def alloc(name, root_path, private): - job = ExtJob(c_ptr=cfunc.alloc(name, root_path, private)) - return job - - @staticmethod - def fscanf_alloc(name, root_path, private, config_file): - job = ExtJob(c_ptr=cfunc.fscanf_alloc(name, root_path, private, config_file)) - return job + def free(self): + ExtJob.cNamespace().free(self) ################################################################## cwrapper = CWrapper(JOB_QUEUE_LIB) cwrapper.registerType("ext_job", ExtJob) +cwrapper.registerType("ext_job_obj", ExtJob.createPythonObject) +cwrapper.registerType("ext_job_ref", ExtJob.createCReference) -cfunc = CWrapperNameSpace("ext_job") -cfunc.free = cwrapper.prototype("void ext_job_free( ext_job )") -cfunc.get_help_text = cwrapper.prototype("char* ext_job_get_help_text(ext_job)") -cfunc.get_private_args_as_string = cwrapper.prototype("char* ext_job_get_private_args_as_string(ext_job)") -cfunc.set_private_args_as_string = cwrapper.prototype("void ext_job_set_private_args_from_string(ext_job, char*)") -cfunc.is_private = cwrapper.prototype("int ext_job_is_private(ext_job)") -cfunc.get_config_file = cwrapper.prototype("char* ext_job_get_config_file(ext_job)") -cfunc.set_config_file = cwrapper.prototype("void ext_job_set_config_file(ext_job, char*)") -cfunc.alloc = cwrapper.prototype("c_void_p ext_job_alloc(char*, char*, int)") -cfunc.fscanf_alloc = cwrapper.prototype("c_void_p ext_job_fscanf_alloc(char*, char*, int, char*)") -cfunc.get_stdin_file = cwrapper.prototype("char* ext_job_get_stdin_file(ext_job)") -cfunc.set_stdin_file = cwrapper.prototype("void ext_job_set_stdin_file(ext_job, char*)") -cfunc.get_stdout_file = cwrapper.prototype("char* ext_job_get_stdout_file(ext_job)") -cfunc.set_stdout_file = cwrapper.prototype("void ext_job_set_stdout_file(ext_job, char*)") -cfunc.get_stderr_file = cwrapper.prototype("char* ext_job_get_stderr_file(ext_job)") -cfunc.set_stderr_file = cwrapper.prototype("void ext_job_set_stderr_file(ext_job, char*)") -cfunc.get_target_file = cwrapper.prototype("char* ext_job_get_target_file(ext_job)") -cfunc.set_target_file = cwrapper.prototype("void ext_job_set_target_file(ext_job, char*)") -cfunc.get_executable = cwrapper.prototype("char* ext_job_get_executable(ext_job)") -cfunc.set_executable = cwrapper.prototype("void ext_job_set_executable(ext_job, char*)") -cfunc.get_max_running = cwrapper.prototype("int ext_job_get_max_running(ext_job)") -cfunc.set_max_running = cwrapper.prototype("void ext_job_set_max_running(ext_job, int)") -cfunc.get_max_running_minutes = cwrapper.prototype("int ext_job_get_max_running_minutes(ext_job)") -cfunc.set_max_running_minutes = cwrapper.prototype("void ext_job_set_max_running_minutes(ext_job, int)") -cfunc.get_environment = cwrapper.prototype("c_void_p ext_job_get_environment(ext_job)") -cfunc.set_environment = cwrapper.prototype("void ext_job_add_environment(ext_job, char*, char*)") -cfunc.clear_environment = cwrapper.prototype("void ext_job_clear_environment(ext_job)") -cfunc.save = cwrapper.prototype("void ext_job_save(ext_job)") +ExtJob.cNamespace().alloc = cwrapper.prototype("c_void_p ext_job_alloc(char*, char*, int)") +ExtJob.cNamespace().fscanf_alloc = cwrapper.prototype("c_void_p ext_job_fscanf_alloc(char*, char*, int, char*)") + +ExtJob.cNamespace().free = cwrapper.prototype("void ext_job_free( ext_job )") +ExtJob.cNamespace().get_help_text = cwrapper.prototype("char* ext_job_get_help_text(ext_job)") +ExtJob.cNamespace().get_private_args_as_string = cwrapper.prototype("char* ext_job_get_private_args_as_string(ext_job)") +ExtJob.cNamespace().set_private_args_as_string = cwrapper.prototype("void ext_job_set_private_args_from_string(ext_job, char*)") +ExtJob.cNamespace().is_private = cwrapper.prototype("int ext_job_is_private(ext_job)") +ExtJob.cNamespace().get_config_file = cwrapper.prototype("char* ext_job_get_config_file(ext_job)") +ExtJob.cNamespace().set_config_file = cwrapper.prototype("void ext_job_set_config_file(ext_job, char*)") +ExtJob.cNamespace().get_stdin_file = cwrapper.prototype("char* ext_job_get_stdin_file(ext_job)") +ExtJob.cNamespace().set_stdin_file = cwrapper.prototype("void ext_job_set_stdin_file(ext_job, char*)") +ExtJob.cNamespace().get_stdout_file = cwrapper.prototype("char* ext_job_get_stdout_file(ext_job)") +ExtJob.cNamespace().set_stdout_file = cwrapper.prototype("void ext_job_set_stdout_file(ext_job, char*)") +ExtJob.cNamespace().get_stderr_file = cwrapper.prototype("char* ext_job_get_stderr_file(ext_job)") +ExtJob.cNamespace().set_stderr_file = cwrapper.prototype("void ext_job_set_stderr_file(ext_job, char*)") +ExtJob.cNamespace().get_target_file = cwrapper.prototype("char* ext_job_get_target_file(ext_job)") +ExtJob.cNamespace().set_target_file = cwrapper.prototype("void ext_job_set_target_file(ext_job, char*)") +ExtJob.cNamespace().get_executable = cwrapper.prototype("char* ext_job_get_executable(ext_job)") +ExtJob.cNamespace().set_executable = cwrapper.prototype("void ext_job_set_executable(ext_job, char*)") +ExtJob.cNamespace().get_max_running = cwrapper.prototype("int ext_job_get_max_running(ext_job)") +ExtJob.cNamespace().set_max_running = cwrapper.prototype("void ext_job_set_max_running(ext_job, int)") +ExtJob.cNamespace().get_max_running_minutes = cwrapper.prototype("int ext_job_get_max_running_minutes(ext_job)") +ExtJob.cNamespace().set_max_running_minutes = cwrapper.prototype("void ext_job_set_max_running_minutes(ext_job, int)") +ExtJob.cNamespace().get_environment = cwrapper.prototype("c_void_p ext_job_get_environment(ext_job)") +ExtJob.cNamespace().set_environment = cwrapper.prototype("void ext_job_add_environment(ext_job, char*, char*)") +ExtJob.cNamespace().clear_environment = cwrapper.prototype("void ext_job_clear_environment(ext_job)") +ExtJob.cNamespace().save = cwrapper.prototype("void ext_job_save(ext_job)") diff --git a/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_joblist.py b/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_joblist.py index 6472304c2f..0efa1476c6 100644 --- a/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_joblist.py +++ b/ThirdParty/Ert/devel/python/python/ert/job_queue/ext_joblist.py @@ -13,50 +13,50 @@ # # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import CWrapper, BaseCClass from ert.job_queue import JOB_QUEUE_LIB, ExtJob from ert.util import StringList -class ExtJoblist(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def get_jobs(self): - return cfunc.get_jobs( self ) +class ExtJoblist(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - @property - def alloc_list(self): - return StringList(c_ptr = cfunc.alloc_list( self ), parent = self) + def get_jobs(self): + """ @rtype: Hash """ + jobs = ExtJoblist.cNamespace().get_jobs(self) + jobs.setParent(self) + return jobs + + def getAvailableJobNames(self): + """ @rtype: StringList """ + return ExtJoblist.cNamespace().alloc_list(self).setParent(self) def del_job(self, job): - return cfunc.del_job(self, job) + return ExtJoblist.cNamespace().del_job(self, job) def has_job(self, job): - return cfunc.has_job(self, job) + return ExtJoblist.cNamespace().has_job(self, job) def get_job(self, job): - return ExtJob( c_ptr = cfunc.get_job( self , job), parent = self) + """ @rtype: ExtJob """ + return ExtJoblist.cNamespace().get_job(self, job).setParent(self) def add_job(self, job_name, new_job): - cfunc.add_job(self, job_name, new_job) -################################################################## + ExtJoblist.cNamespace().add_job(self, job_name, new_job) + + def free(self): + ExtJoblist.cNamespace().free(self) cwrapper = CWrapper(JOB_QUEUE_LIB) -cwrapper.registerType( "ext_joblist" , ExtJoblist ) +cwrapper.registerType("ext_joblist", ExtJoblist) +cwrapper.registerType("ext_joblist_obj", ExtJoblist.createPythonObject) +cwrapper.registerType("ext_joblist_ref", ExtJoblist.createCReference) -cfunc = CWrapperNameSpace("ext_joblist") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void ext_joblist_free( ext_joblist )") -cfunc.alloc_list = cwrapper.prototype("c_void_p ext_joblist_alloc_list(ext_joblist)") -cfunc.get_job = cwrapper.prototype("c_void_p ext_joblist_get_job(ext_joblist, char*)") -cfunc.del_job = cwrapper.prototype("int ext_joblist_del_job(ext_joblist, char*)") -cfunc.has_job = cwrapper.prototype("int ext_joblist_has_job(ext_joblist, char*)") -cfunc.add_job = cwrapper.prototype("void ext_joblist_add_job(ext_joblist, char*, ext_joblist)") -cfunc.get_jobs = cwrapper.prototype("c_void_p ext_joblist_get_jobs(ext_joblist)") +ExtJoblist.cNamespace().free = cwrapper.prototype("void ext_joblist_free( ext_joblist )") +ExtJoblist.cNamespace().alloc_list = cwrapper.prototype("stringlist_ref ext_joblist_alloc_list(ext_joblist)") +ExtJoblist.cNamespace().get_job = cwrapper.prototype("ext_job_ref ext_joblist_get_job(ext_joblist, char*)") +ExtJoblist.cNamespace().del_job = cwrapper.prototype("int ext_joblist_del_job(ext_joblist, char*)") +ExtJoblist.cNamespace().has_job = cwrapper.prototype("int ext_joblist_has_job(ext_joblist, char*)") +ExtJoblist.cNamespace().add_job = cwrapper.prototype("void ext_joblist_add_job(ext_joblist, char*, ext_joblist)") +ExtJoblist.cNamespace().get_jobs = cwrapper.prototype("hash_ref ext_joblist_get_jobs(ext_joblist)") diff --git a/ThirdParty/Ert/devel/python/python/ert/job_queue/forward_model.py b/ThirdParty/Ert/devel/python/python/ert/job_queue/forward_model.py index 9966aad3b3..d0b86fed95 100644 --- a/ThirdParty/Ert/devel/python/python/ert/job_queue/forward_model.py +++ b/ThirdParty/Ert/devel/python/python/ert/job_queue/forward_model.py @@ -13,44 +13,40 @@ # # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import CWrapper, BaseCClass from ert.job_queue import ExtJob, JOB_QUEUE_LIB from ert.util import StringList -class ForwardModel(CClass): - - def __init__(self , c_ptr , parent = None): - if parent: - self.init_cref( c_ptr , parent) - else: - self.init_cobj( c_ptr , cfunc.free ) - - @property - def alloc_joblist(self): - s = StringList(initial = None, c_ptr = cfunc.alloc_joblist(self)) - return s +class ForwardModel(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + + def joblist(self): + """ @rtype: StringList """ + return ForwardModel.cNamespace().alloc_joblist(self) def iget_job(self, index): - job = ExtJob( cfunc.iget_job( self, index ), parent = self) - return job + """ @rtype: ExtJob """ + return ForwardModel.cNamespace().iget_job(self, index).setParent(self) def add_job(self, name): - job = ExtJob( cfunc.add_job( self, name ), parent = self) - return job + """ @rtype: ExtJob """ + return ForwardModel.cNamespace().add_job(self, name).setParent(self) def clear(self): - cfunc.clear(self) -################################################################## + ForwardModel.cNamespace().clear(self) + + def free(self): + ForwardModel.cNamespace().free(self) cwrapper = CWrapper(JOB_QUEUE_LIB) -cwrapper.registerType( "forward_model" , ForwardModel ) +cwrapper.registerType("forward_model", ForwardModel) +cwrapper.registerType("forward_model_obj", ForwardModel.createPythonObject) +cwrapper.registerType("forward_model_ref", ForwardModel.createCReference) -cfunc = CWrapperNameSpace("forward_model") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void forward_model_free( forward_model )") -cfunc.clear = cwrapper.prototype("void forward_model_clear(forward_model)") -cfunc.add_job = cwrapper.prototype("c_void_p forward_model_add_job(forward_model, char*)") -cfunc.alloc_joblist = cwrapper.prototype("c_void_p forward_model_alloc_joblist(forward_model)") -cfunc.iget_job = cwrapper.prototype("c_void_p forward_model_iget_job( forward_model, int)") +ForwardModel.cNamespace().free = cwrapper.prototype("void forward_model_free( forward_model )") +ForwardModel.cNamespace().clear = cwrapper.prototype("void forward_model_clear(forward_model)") +ForwardModel.cNamespace().add_job = cwrapper.prototype("ext_job_ref forward_model_add_job(forward_model, char*)") +ForwardModel.cNamespace().alloc_joblist = cwrapper.prototype("stringlist_obj forward_model_alloc_joblist(forward_model)") +ForwardModel.cNamespace().iget_job = cwrapper.prototype("ext_job_ref forward_model_iget_job( forward_model, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/job_queue/queue.py b/ThirdParty/Ert/devel/python/python/ert/job_queue/queue.py index b9ab94a26b..b0bd7e4d1a 100644 --- a/ThirdParty/Ert/devel/python/python/ert/job_queue/queue.py +++ b/ThirdParty/Ert/devel/python/python/ert/job_queue/queue.py @@ -17,16 +17,10 @@ Module implementing a queue for managing external jobs. """ - -import time import ctypes - from types import StringType, IntType - - -# Need to import this to ensure that the ctime type is registered -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace -from ert.util.ctime import ctime +import time +from ert.cwrap import BaseCClass, CWrapper from ert.job_queue import JOB_QUEUE_LIB, Job @@ -87,13 +81,17 @@ class statusList: class runtimeList: def __init__(self, job_list, queue): + """ + @type job_list: JobList + @type queue: JobQueue + """ self.job_list = job_list self.queue = queue def __getitem__(self, index): job = self.job_list.__getitem__(index) if job: - sim_start = cfunc.iget_sim_start(self.queue, job.job_nr) + sim_start = self.queue.cNamespace().iget_sim_start(self.queue, job.job_nr) if not sim_start.ctime() == -1: return time.time() - sim_start.ctime() else: @@ -102,7 +100,7 @@ class runtimeList: return None -class JobQueue(CClass): +class JobQueue(BaseCClass): # If the queue is created with size == 0 that means that it will # just grow as needed; for the queue layer to know when to exit # you must call the function submit_complete() when you have no @@ -136,8 +134,8 @@ class JobQueue(CClass): OK_file = None exit_file = None - c_ptr = cfunc.alloc(max_submit, OK_file, exit_file) - self.init_cobj(c_ptr, cfunc.free) + c_ptr = JobQueue.cNamespace().alloc(max_submit, OK_file, exit_file) + super(JobQueue, self).__init__(c_ptr) self.jobs = JobList() self.size = size @@ -149,7 +147,7 @@ class JobQueue(CClass): self.start(blocking=False) if driver: self.driver = driver - cfunc.set_driver(self, driver.c_ptr) + JobQueue.cNamespace().set_driver(self, driver.c_ptr) def kill_job(self, index): @@ -162,7 +160,7 @@ class JobQueue(CClass): def start( self, blocking=False): verbose = False - cfunc.run_jobs(self, self.size, verbose) + JobQueue.cNamespace().run_jobs(self, self.size, verbose) def submit( self, cmd, run_path, job_name, argv, num_cpu=1): @@ -174,17 +172,18 @@ class JobQueue(CClass): callback_arg = None retry_callback = None - queue_index = cfunc.cadd_job_mt(self, - cmd, - done_callback, - retry_callback, - callback_arg, - num_cpu, - run_path, - job_name, - len(argv), - c_argv) - job = Job(self.driver, cfunc.get_job_ptr(self, queue_index), queue_index, False) + queue_index = JobQueue.cNamespace().add_job_mt(self, + cmd, + done_callback, + retry_callback, + callback_arg, + num_cpu, + run_path, + job_name, + len(argv), + c_argv) + + job = Job(self.driver, JobQueue.cNamespace().get_job_ptr(self, queue_index), queue_index, False) self.jobs.add_job(job, job_name) return job @@ -204,7 +203,7 @@ class JobQueue(CClass): """ Will block as long as there are running jobs. """ - while self.running: + while self.isRunning: time.sleep(1) @@ -222,28 +221,23 @@ class JobQueue(CClass): queue, in that case it is not necessary to call the submit_complete() method. """ - cfunc.submit_complete(self) + JobQueue.cNamespace().submit_complete(self) - @property - def running(self): - return cfunc.is_running(self) + def isRunning(self): + return JobQueue.cNamespace().is_running(self) - @property def num_running( self ): - return cfunc.num_running(self) + return JobQueue.cNamespace().num_running(self) - @property def num_pending( self ): - return cfunc.num_pending(self) + return JobQueue.cNamespace().num_pending(self) - @property def num_waiting( self ): - return cfunc.num_waiting(self) + return JobQueue.cNamespace().num_waiting(self) - @property def num_complete( self ): - return cfunc.num_complete(self) + return JobQueue.cNamespace().num_complete(self) def exists(self, index): job = self.__getitem__(index) @@ -259,41 +253,45 @@ class JobQueue(CClass): self.driver.set_max_running(max_running) def user_exit(self): - cfunc.user_exit(self) + JobQueue.cNamespace().user_exit(self) def set_pause_on(self): - cfunc.set_pause_on() + JobQueue.cNamespace().set_pause_on(self) def set_pause_off(self): - cfunc.set_pause_off() + JobQueue.cNamespace().set_pause_off(self) + + def free(self): + JobQueue.cNamespace().free(self) ################################################################# cwrapper = CWrapper(JOB_QUEUE_LIB) cwrapper.registerType("job_queue", JobQueue) -cfunc = CWrapperNameSpace("JobQueue") +cwrapper.registerType("job_queue_obj", JobQueue.createPythonObject) +cwrapper.registerType("job_queue_ref", JobQueue.createCReference) -cfunc.alloc = cwrapper.prototype("c_void_p job_queue_alloc( int , char* , char* )") -cfunc.user_exit = cwrapper.prototype("void job_queue_user_exit( job_queue )") -cfunc.free = cwrapper.prototype("void job_queue_free( job_queue )") -cfunc.set_max_running = cwrapper.prototype("void job_queue_set_max_running( job_queue , int)") -cfunc.get_max_running = cwrapper.prototype("int job_queue_get_max_running( job_queue )") -cfunc.set_driver = cwrapper.prototype("void job_queue_set_driver( job_queue , c_void_p )") -cfunc.cadd_job_mt = cwrapper.prototype("int job_queue_add_job_mt( job_queue , char* , c_void_p , c_void_p , c_void_p , int , char* , char* , int , char**)") -cfunc.cadd_job_st = cwrapper.prototype("int job_queue_add_job_st( job_queue , char* , c_void_p , c_void_p , c_void_p , int , char* , char* , int , char**)") -cfunc.start_queue = cwrapper.prototype("void job_queue_run_jobs( job_queue , int , bool)") -cfunc.run_jobs = cwrapper.prototype("void job_queue_run_jobs_threaded(job_queue , int , bool)") +JobQueue.cNamespace().alloc = cwrapper.prototype("c_void_p job_queue_alloc( int , char* , char* )") +JobQueue.cNamespace().user_exit = cwrapper.prototype("void job_queue_user_exit( job_queue )") +JobQueue.cNamespace().free = cwrapper.prototype("void job_queue_free( job_queue )") +JobQueue.cNamespace().set_max_running = cwrapper.prototype("void job_queue_set_max_running( job_queue , int)") +JobQueue.cNamespace().get_max_running = cwrapper.prototype("int job_queue_get_max_running( job_queue )") +JobQueue.cNamespace().set_driver = cwrapper.prototype("void job_queue_set_driver( job_queue , c_void_p )") +JobQueue.cNamespace().add_job_mt = cwrapper.prototype("int job_queue_add_job_mt( job_queue , char* , c_void_p , c_void_p , c_void_p , int , char* , char* , int , char**)") +JobQueue.cNamespace().add_job_st = cwrapper.prototype("int job_queue_add_job_st( job_queue , char* , c_void_p , c_void_p , c_void_p , int , char* , char* , int , char**)") +JobQueue.cNamespace().start_queue = cwrapper.prototype("void job_queue_run_jobs( job_queue , int , bool)") +JobQueue.cNamespace().run_jobs = cwrapper.prototype("void job_queue_run_jobs_threaded(job_queue , int , bool)") -cfunc.num_running = cwrapper.prototype("int job_queue_get_num_running( job_queue )") -cfunc.num_complete = cwrapper.prototype("int job_queue_get_num_complete( job_queue )") -cfunc.num_waiting = cwrapper.prototype("int job_queue_get_num_waiting( job_queue )") -cfunc.num_pending = cwrapper.prototype("int job_queue_get_num_pending( job_queue )") +JobQueue.cNamespace().num_running = cwrapper.prototype("int job_queue_get_num_running( job_queue )") +JobQueue.cNamespace().num_complete = cwrapper.prototype("int job_queue_get_num_complete( job_queue )") +JobQueue.cNamespace().num_waiting = cwrapper.prototype("int job_queue_get_num_waiting( job_queue )") +JobQueue.cNamespace().num_pending = cwrapper.prototype("int job_queue_get_num_pending( job_queue )") -cfunc.is_running = cwrapper.prototype("int job_queue_is_running( job_queue )") -cfunc.submit_complete = cwrapper.prototype("void job_queue_submit_complete( job_queue )") -cfunc.get_job_ptr = cwrapper.prototype("c_void_p job_queue_iget_job( job_queue , int)") -cfunc.iget_sim_start = cwrapper.prototype("int job_queue_iget_sim_start( job_queue , int)") -cfunc.get_active_size = cwrapper.prototype("int job_queue_get_active_size( job_queue )") -cfunc.get_pause = cwrapper.prototype("bool job_queue_get_pause(job_queue)") -cfunc.set_pause_on = cwrapper.prototype("void job_queue_set_pause_on(job_queue)") -cfunc.set_pause_off = cwrapper.prototype("void job_queue_set_pause_off(job_queue)") +JobQueue.cNamespace().is_running = cwrapper.prototype("int job_queue_is_running( job_queue )") +JobQueue.cNamespace().submit_complete = cwrapper.prototype("void job_queue_submit_complete( job_queue )") +JobQueue.cNamespace().get_job_ptr = cwrapper.prototype("c_void_p job_queue_iget_job( job_queue , int)") #warn fix return type +JobQueue.cNamespace().iget_sim_start = cwrapper.prototype("int job_queue_iget_sim_start( job_queue , int)") +JobQueue.cNamespace().get_active_size = cwrapper.prototype("int job_queue_get_active_size( job_queue )") +JobQueue.cNamespace().get_pause = cwrapper.prototype("bool job_queue_get_pause(job_queue)") +JobQueue.cNamespace().set_pause_on = cwrapper.prototype("void job_queue_set_pause_on(job_queue)") +JobQueue.cNamespace().set_pause_off = cwrapper.prototype("void job_queue_set_pause_off(job_queue)") diff --git a/ThirdParty/Ert/devel/python/python/ert/sched/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/sched/CMakeLists.txt index 714bb73a2b..d76556c45d 100644 --- a/ThirdParty/Ert/devel/python/python/ert/sched/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/python/ert/sched/CMakeLists.txt @@ -1,7 +1,8 @@ set(PYTHON_SOURCES __init__.py - sched_file.py history.py + history_source_enum.py + sched_file.py ) add_python_package("Python ert.sched" ${PYTHON_INSTALL_PREFIX}/ert/sched "${PYTHON_SOURCES}" True) diff --git a/ThirdParty/Ert/devel/python/python/ert/sched/__init__.py b/ThirdParty/Ert/devel/python/python/ert/sched/__init__.py index 5257711e70..55bcc4477e 100644 --- a/ThirdParty/Ert/devel/python/python/ert/sched/__init__.py +++ b/ThirdParty/Ert/devel/python/python/ert/sched/__init__.py @@ -23,4 +23,5 @@ SCHED_LIB = clib.ert_load("libsched.so") from .sched_file import SchedFile -from .history import HistoryType \ No newline at end of file +from .history_source_enum import HistorySourceEnum +from .history import History \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/sched/history.py b/ThirdParty/Ert/devel/python/python/ert/sched/history.py index 144ffb4a9e..10204a7d4e 100644 --- a/ThirdParty/Ert/devel/python/python/ert/sched/history.py +++ b/ThirdParty/Ert/devel/python/python/ert/sched/history.py @@ -13,39 +13,55 @@ # # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace -from ert.sched import SCHED_LIB + +from ert.cwrap import CWrapper, BaseCClass +from ert.sched import SCHED_LIB, SchedFile, HistorySourceEnum +from ert.ecl import EclSum -class HistoryType(CClass): - def __init__(self, c_ptr, parent=None): - if parent: - self.init_cref(c_ptr, parent) - else: - self.init_cobj(c_ptr, cfunc.free) - def get_source_string(self): - return cfunc.get_source_string(self) +class History(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") + @staticmethod + def get_source_string(history_source_type): + """ + @type history_source_type: HistorySourceEnum + @rtype: str + """ + return History.cNamespace().get_source_string(history_source_type) + + #todo: change this to __init__? @staticmethod def alloc_from_refcase(refcase, use_history): - return HistoryType(cfunc.alloc_from_refcase(refcase, use_history)) + """ + @type refcase: EclSum + @type use_history: bool + @rtype: HistoryType + """ + return History.cNamespace().alloc_from_refcase(refcase, use_history) @staticmethod def alloc_from_sched_file(sched_file): - return HistoryType(cfunc.alloc_from_sched_file(":", sched_file)) + """ @rtype: HistoryType """ + assert isinstance(sched_file, SchedFile) + return History.cNamespace().alloc_from_sched_file(":", sched_file) + + def free(self): + History.cNamespace().free(self) - ################################################################## cwrapper = CWrapper(SCHED_LIB) -cwrapper.registerType("history_type", HistoryType) +cwrapper.registerType("history", History) +cwrapper.registerType("history_obj", History.createPythonObject) +cwrapper.registerType("history_ref", History.createCReference) -cfunc = CWrapperNameSpace("history_type") -################################################################## -################################################################## -cfunc.free = cwrapper.prototype("void history_free( history_type )") -cfunc.get_source_string = cwrapper.prototype("char* history_get_source_string(history_type)") -cfunc.alloc_from_refcase = cwrapper.prototype("c_void_p history_alloc_from_refcase(ecl_sum, bool)") -cfunc.alloc_from_sched_file = cwrapper.prototype("c_void_p history_alloc_from_sched_file(char*, c_void_p)") +History.cNamespace().free = cwrapper.prototype("void history_free( history )") +History.cNamespace().get_source_string = cwrapper.prototype("char* history_get_source_string(history_source_enum)") +History.cNamespace().alloc_from_refcase = cwrapper.prototype("history_obj history_alloc_from_refcase(ecl_sum, bool)") +History.cNamespace().alloc_from_sched_file = cwrapper.prototype("history_obj history_alloc_from_sched_file(char*, sched_file)") + +# History.cNamespace().history_get_source_type = cwrapper.prototype("history_source_type_enum history_get_source_type(char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/sched/history_source_enum.py b/ThirdParty/Ert/devel/python/python/ert/sched/history_source_enum.py new file mode 100644 index 0000000000..e00a1da023 --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/sched/history_source_enum.py @@ -0,0 +1,13 @@ +from ert.cwrap import BaseCEnum +from ert.sched import SCHED_LIB + + +class HistorySourceEnum(BaseCEnum): + pass + +HistorySourceEnum.addEnum("SCHEDULE", 0) +HistorySourceEnum.addEnum("REFCASE_SIMULATED", 1) +HistorySourceEnum.addEnum("REFCASE_HISTORY", 2) +HistorySourceEnum.addEnum("HISTORY_SOURCE_INVALID", 10) + +HistorySourceEnum.registerEnum(SCHED_LIB, "history_source_enum") diff --git a/ThirdParty/Ert/devel/python/python/ert/sched/sched_file.py b/ThirdParty/Ert/devel/python/python/ert/sched/sched_file.py index b6095fd20d..722b5fe11c 100644 --- a/ThirdParty/Ert/devel/python/python/ert/sched/sched_file.py +++ b/ThirdParty/Ert/devel/python/python/ert/sched/sched_file.py @@ -13,36 +13,34 @@ # # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import BaseCClass, CWrapper from ert.sched import SCHED_LIB from ert.util import ctime -class SchedFile(CClass): - - def __init__(self , filename , start_time): - c_ptr = cfunc.parse( filename , ctime( start_time )) - self.init_cobj( c_ptr , cfunc.free ) - +class SchedFile(BaseCClass): + def __init__(self, filename, start_time): + c_ptr = SchedFile.cNamespace().parse(filename, ctime(start_time)) + super(SchedFile, self).__init__(c_ptr) @property def length(self): - return cfunc.length( self ) + """ @rtype: int """ + return SchedFile.cNamespace().length(self) - def write( self , filename , num_dates , add_end = True): - cfunc.write(self , num_dates , filename , add_end) + def write(self, filename, num_dates, add_end=True): + SchedFile.cNamespace().write(self, num_dates, filename, add_end) + def free(self): + SchedFile.cNamespace().free(self) cwrapper = CWrapper(SCHED_LIB) -cwrapper.registerType( "sched_file" , SchedFile ) +cwrapper.registerType("sched_file", SchedFile) +cwrapper.registerType("sched_file_obj", SchedFile.createPythonObject) +cwrapper.registerType("sched_file_ref", SchedFile.createCReference) -# 3. Installing the c-functions used to manipulate ecl_kw instances. -# These functions are used when implementing the EclKW class, not -# used outside this scope. -cfunc = CWrapperNameSpace("sched_file") - -cfunc.parse = cwrapper.prototype("c_void_p sched_file_parse_alloc( char*, time_t )") -cfunc.write = cwrapper.prototype("void sched_file_fprintf_i( sched_file , int , char* , bool)") -cfunc.length = cwrapper.prototype("int sched_file_get_num_restart_files( sched_file )") -cfunc.free = cwrapper.prototype("void sched_file_free( sched_file )") +SchedFile.cNamespace().parse = cwrapper.prototype("c_void_p sched_file_parse_alloc( char*, time_t )") +SchedFile.cNamespace().write = cwrapper.prototype("void sched_file_fprintf_i( sched_file , int , char* , bool)") +SchedFile.cNamespace().length = cwrapper.prototype("int sched_file_get_num_restart_files( sched_file )") +SchedFile.cNamespace().free = cwrapper.prototype("void sched_file_free( sched_file )") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/CMakeLists.txt b/ThirdParty/Ert/devel/python/python/ert/util/CMakeLists.txt index fd40f8ebd0..3f99aca41c 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/python/ert/util/CMakeLists.txt @@ -9,6 +9,7 @@ set(PYTHON_SOURCES matrix.py stat.py stringlist.py + substitution_list.py tvector.py util_func.py diff --git a/ThirdParty/Ert/devel/python/python/ert/util/__init__.py b/ThirdParty/Ert/devel/python/python/ert/util/__init__.py index 95010d5a28..469a1d645b 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/__init__.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/__init__.py @@ -63,6 +63,6 @@ from .log import Log from .lookup_table import LookupTable from .buffer import Buffer from .ctime import ctime -from .hash import Hash -from .test_area import TestArea, TestAreaContext -from .latex import LaTeX \ No newline at end of file +from .hash import Hash, StringHash, DoubleHash, IntegerHash +from .latex import LaTeX +from .substitution_list import SubstitutionList \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/util/buffer.py b/ThirdParty/Ert/devel/python/python/ert/util/buffer.py index 1067af70aa..4da72a9049 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/buffer.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/buffer.py @@ -14,25 +14,24 @@ # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import BaseCClass, CWrapper from ert.util import UTIL_LIB -class Buffer(CClass): - def __init__(self, size, parent=None): - c_ptr = cfunc.alloc(size) - if parent: - self.init_cref(c_ptr, parent) - else: - self.init_cobj(c_ptr, cfunc.free) +class Buffer(BaseCClass): + def __init__(self, size): + super(Buffer, self).__init__(Buffer.cNamespace().alloc(size)) + def free(self): + Buffer.cNamespace().free(self) ################################################################## cwrapper = CWrapper(UTIL_LIB) cwrapper.registerType("buffer", Buffer) +cwrapper.registerType("buffer_obj", Buffer.createPythonObject) +cwrapper.registerType("buffer_ref", Buffer.createCReference) -cfunc = CWrapperNameSpace("buffer") -cfunc.free = cwrapper.prototype("void buffer_free( buffer )") -cfunc.alloc = cwrapper.prototype("c_void_p buffer_alloc(int)") +Buffer.cNamespace().free = cwrapper.prototype("void buffer_free(buffer)") +Buffer.cNamespace().alloc = cwrapper.prototype("c_void_p buffer_alloc(int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/hash.py b/ThirdParty/Ert/devel/python/python/ert/util/hash.py index 3f9ced5742..6242324e86 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/hash.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/hash.py @@ -12,29 +12,137 @@ # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at -# for more details. +# for more details. +from ctypes import c_void_p + +from ert.cwrap import CWrapper, BaseCClass +from ert.util import UTIL_LIB, StringList -from ert.cwrap import CWrapper, CWrapperNameSpace, CClass -from ert.util import UTIL_LIB + +class Hash(BaseCClass): + """ + Base hash class that supports string c_void_p values + """ + def __init__(self): + c_ptr = Hash.cNamespace().alloc() + super(Hash, self).__init__(c_ptr) + + def __len__(self): + return Hash.cNamespace().size(self) + + def __getitem__(self, key): + if Hash.cNamespace().has_key(self, key): + return Hash.cNamespace().get(self, key) + else: + raise KeyError("Hash does not have key: %s" % key) + + def __setitem__(self, key, value): + if isinstance(value, c_void_p): + Hash.cNamespace().insert_ref(self, key, value) + else: + raise ValueError("Hash does not support type: %s" % value.__class__) + + def __contains__(self, key): + """ @rtype: bool """ + return Hash.cNamespace().has_key(self, key) + + def __iter__(self): + for key in self.keys(): + yield key + + def keys(self): + """ @rtype: StringList """ + return Hash.cNamespace().keys(self) + + def free(self): + Hash.cNamespace().free(self) -class Hash(CClass): - def __init__( self ): - self.c_ptr = cfunc.hash_alloc() +class StringHash(Hash): + def __init__(self): + super(StringHash, self).__init__() - def __del__( self ): - cfunc.hash_del(self) - - def __getitem__(self, key): #todo: missing implementation? - pass + def __setitem__(self, key, value): + if isinstance(value, str): + StringHash.cNamespace().insert_string(self, key, value) + else: + raise ValueError("StringHash does not support type: %s" % value.__class__) + + + def __getitem__(self, key): + if key in self: + return StringHash.cNamespace().get_string(self, key) + else: + raise KeyError("Hash does not have key: %s" % key) + +class IntegerHash(Hash): + def __init__(self): + super(IntegerHash, self).__init__() + + def __setitem__(self, key, value): + if isinstance(value, int): + IntegerHash.cNamespace().insert_int(self, key, value) + else: + raise ValueError("IntegerHash does not support type: %s" % value.__class__) + + + def __getitem__(self, key): + if key in self: + return IntegerHash.cNamespace().get_int(self, key) + else: + raise KeyError("Hash does not have key: %s" % key) + +class DoubleHash(Hash): + def __init__(self): + super(DoubleHash, self).__init__() + + def __setitem__(self, key, value): + if isinstance(value, int): + value = float(value) + + if isinstance(value, float): + DoubleHash.cNamespace().insert_double(self, key, value) + else: + raise ValueError("DoubleHash does not support type: %s" % value.__class__) + + + def __getitem__(self, key): + if key in self: + return DoubleHash.cNamespace().get_double(self, key) + else: + raise KeyError("Hash does not have key: %s" % key) -CWrapper.registerType("hash", Hash) cwrapper = CWrapper(UTIL_LIB) +CWrapper.registerType("hash", Hash) #c_void_p type +CWrapper.registerType("integer_hash", IntegerHash) +CWrapper.registerType("string_has", StringHash) +CWrapper.registerType("double_hash", DoubleHash) -cfunc = CWrapperNameSpace("hash") +CWrapper.registerType("hash_obj", Hash.createPythonObject) #c_void_p type +CWrapper.registerType("string_hash_obj", StringHash.createPythonObject) +CWrapper.registerType("integer_hash_obj", IntegerHash.createPythonObject) +CWrapper.registerType("double_hash_obj", DoubleHash.createPythonObject) -cfunc.hash_alloc = cwrapper.prototype("long hash_alloc( )") -cfunc.hash_free = cwrapper.prototype("void hash_free( hash )") -cfunc.hash_get = cwrapper.prototype("long hash_get(hash , char*)") +CWrapper.registerType("hash_ref", Hash.createCReference) #c_void_p type +CWrapper.registerType("string_hash_ref", StringHash.createCReference) +CWrapper.registerType("integer_hash_ref", IntegerHash.createCReference) +CWrapper.registerType("double_hash_ref", DoubleHash.createCReference) + + +Hash.cNamespace().alloc = cwrapper.prototype("long hash_alloc()") +Hash.cNamespace().free = cwrapper.prototype("void hash_free(hash)") +Hash.cNamespace().size = cwrapper.prototype("int hash_get_size(hash)") +Hash.cNamespace().keys = cwrapper.prototype("stringlist_obj hash_alloc_stringlist(hash)") +Hash.cNamespace().has_key = cwrapper.prototype("bool hash_has_key(hash, char*)") + +Hash.cNamespace().get = cwrapper.prototype("c_void_p hash_get(hash, char*)") +IntegerHash.cNamespace().get_int = cwrapper.prototype("int hash_get_int(hash, char*)") +DoubleHash.cNamespace().get_double = cwrapper.prototype("double hash_get_double(hash, char*)") +StringHash.cNamespace().get_string = cwrapper.prototype("char* hash_get_string(hash, char*)") + +Hash.cNamespace().insert_ref = cwrapper.prototype("void hash_insert_ref(hash, char*, c_void_p)") +IntegerHash.cNamespace().insert_int = cwrapper.prototype("void hash_insert_int(hash, char*, int)") +DoubleHash.cNamespace().insert_double = cwrapper.prototype("void hash_insert_double(hash, char*, double)") +StringHash.cNamespace().insert_string = cwrapper.prototype("void hash_insert_string(hash, char*, char*)") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/log.py b/ThirdParty/Ert/devel/python/python/ert/util/log.py index ec74372aee..0f1de67f01 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/log.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/log.py @@ -14,43 +14,38 @@ # See the GNU General Public License at # for more details. -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import CWrapper, BaseCClass from ert.util import UTIL_LIB -class Log(CClass): - def __init__(self, c_ptr, parent=None): - if parent: - self.init_cref(c_ptr, parent) - else: - self.init_cobj(c_ptr, cfunc.free) +class Log(BaseCClass): + def __init__(self): + raise NotImplementedError("Class can not be instantiated directly!") - @property def get_filename(self): - #return cfunc.get_filename( self ) - return "ert_config.log" + return Log.cNamespace().get_filename( self ) + # return "ert_config.log" def reopen(self, filename): print "Logfile cannot be reopened" #cfunc.reopen( self , filename) - @property def get_level(self): - #return cfunc.get_level( self ) - return 0 + return Log.cNamespace().get_level( self ) def set_level(self, level): - cfunc.set_level(self, level) + pass + # Log.cNamespace().set_level(self, level) ################################################################## cwrapper = CWrapper(UTIL_LIB) cwrapper.registerType("log", Log) +cwrapper.registerType("log_obj", Log.createPythonObject) +cwrapper.registerType("log_ref", Log.createCReference) -cfunc = CWrapperNameSpace("log") -cfunc.free = cwrapper.prototype("void log( log )") -cfunc.get_filename = cwrapper.prototype("char* log_get_filename(log)") -cfunc.reopen = cwrapper.prototype("void log_reopen(log, char*)") -cfunc.get_level = cwrapper.prototype("int log_get_level(log)") -cfunc.set_level = cwrapper.prototype("void log_set_level(log, int)") +Log.cNamespace().get_filename = cwrapper.prototype("char* log_get_filename(log)") +Log.cNamespace().reopen = cwrapper.prototype("void log_reopen(log, char*)") +Log.cNamespace().get_level = cwrapper.prototype("int log_get_level(log)") +Log.cNamespace().set_level = cwrapper.prototype("void log_set_level(log, int)") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/lookup_table.py b/ThirdParty/Ert/devel/python/python/ert/util/lookup_table.py index 1eca28b904..7b629e7c51 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/lookup_table.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/lookup_table.py @@ -16,59 +16,62 @@ from ert.util import UTIL_LIB -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import BaseCClass, CWrapper, CWrapperNameSpace -class LookupTable(CClass): +class LookupTable(BaseCClass): def __init__(self): - self.c_ptr = cfunc.alloc() + super(LookupTable, self).__init__(LookupTable.cNamespace().alloc()) @property def max(self): - return cfunc.max(self) + return LookupTable.cNamespace().max(self) @property def min(self): - return cfunc.min(self) + return LookupTable.cNamespace().min(self) @property def arg_max(self): - return cfunc.arg_max(self) + return LookupTable.cNamespace().arg_max(self) @property def arg_min(self): - return cfunc.arg_min(self) + return LookupTable.cNamespace().arg_min(self) def interp(self, x): - return cfunc.interp(self, x) + return LookupTable.cNamespace().interp(self, x) def append(self, x, y): - cfunc.append(self, x, y) + LookupTable.cNamespace().append(self, x, y) @property def size(self): - return cfunc.size(self) + return LookupTable.cNamespace().size(self) def __del__(self): - cfunc.free(self) + LookupTable.cNamespace().free(self) def __len__(self): return self.size + def free(self): + LookupTable.cNamespace().free(self) + -CWrapper.registerType("lookup_table", LookupTable) cwrapper = CWrapper(UTIL_LIB) +CWrapper.registerType("lookup_table", LookupTable) +CWrapper.registerType("lookup_table_obj", LookupTable.createPythonObject) +CWrapper.registerType("lookup_table_ref", LookupTable.createCReference) -cfunc = CWrapperNameSpace("lookup_table") - -cfunc.alloc = cwrapper.prototype("c_void_p lookup_table_alloc_empty()") -cfunc.max = cwrapper.prototype("double lookup_table_get_max_value( lookup_table )") -cfunc.min = cwrapper.prototype("double lookup_table_get_min_value( lookup_table )") -cfunc.arg_max = cwrapper.prototype("double lookup_table_get_max_arg( lookup_table )") -cfunc.arg_min = cwrapper.prototype("double lookup_table_get_min_arg( lookup_table )") -cfunc.append = cwrapper.prototype("void lookup_table_append( lookup_table , double , double )") -cfunc.size = cwrapper.prototype("int lookup_table_get_size( lookup_table )") -cfunc.interp = cwrapper.prototype("double lookup_table_interp( lookup_table , double)") -cfunc.free = cwrapper.prototype("void lookup_table_free( lookup_table )") +LookupTable.cNamespace().alloc = cwrapper.prototype("c_void_p lookup_table_alloc_empty()") +LookupTable.cNamespace().max = cwrapper.prototype("double lookup_table_get_max_value( lookup_table )") +LookupTable.cNamespace().min = cwrapper.prototype("double lookup_table_get_min_value( lookup_table )") +LookupTable.cNamespace().arg_max = cwrapper.prototype("double lookup_table_get_max_arg( lookup_table )") +LookupTable.cNamespace().arg_min = cwrapper.prototype("double lookup_table_get_min_arg( lookup_table )") +LookupTable.cNamespace().append = cwrapper.prototype("void lookup_table_append( lookup_table , double , double )") +LookupTable.cNamespace().size = cwrapper.prototype("int lookup_table_get_size( lookup_table )") +LookupTable.cNamespace().interp = cwrapper.prototype("double lookup_table_interp( lookup_table , double)") +LookupTable.cNamespace().free = cwrapper.prototype("void lookup_table_free( lookup_table )") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/stringlist.py b/ThirdParty/Ert/devel/python/python/ert/util/stringlist.py index 783b9b95a8..6501527e47 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/stringlist.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/stringlist.py @@ -34,24 +34,12 @@ import sys from ert.util import UTIL_LIB from types import StringType, IntType -from ert.cwrap import CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import CWrapper, BaseCClass -class StringList(CClass): - #@classmethod - #def NULL( cls ): - # obj = object.__new__( cls ) - # obj.c_ptr = None - # return obj - # - # - #@classmethod - #def wrap_ptr( cls , c_ptr ): - # obj = cls( c_ptr = c_ptr ) - # return obj +class StringList(BaseCClass): - - def __init__( self, initial=None, c_ptr=None, parent=None): + def __init__( self, initial=None): """ Creates a new stringlist instance. @@ -69,21 +57,16 @@ class StringList(CClass): an already created stringlist instance; this Python will take ownership of the underlying object. """ - if c_ptr: - if parent: - self.init_cref(c_ptr, parent) - else: - self.init_cobj(c_ptr, cfunc.free) - else: - c_ptr = cfunc.stringlist_alloc() - self.init_cobj(c_ptr, cfunc.free) - if initial: - for s in initial: - if isinstance(s, StringType): - self.append(s) - else: - raise TypeError("Item:%s not a string" % s) + c_ptr = StringList.cNamespace().stringlist_alloc() + super(StringList, self).__init__(c_ptr) + + if initial: + for s in initial: + if isinstance(s, StringType): + self.append(s) + else: + raise TypeError("Item:%s not a string" % s) def __setitem__(self, index, value): @@ -91,12 +74,12 @@ class StringList(CClass): length = self.__len__() if index < 0: # Will only wrap backwards once - index = self.size + index + index = self.size() + index if index < 0 or index >= length: raise IndexError if isinstance(value, StringType): - cfunc.stringlist_iset(self, index, value) + StringList.cNamespace().stringlist_iset(self, index, value) else: raise TypeError("Item:%s not string type" % value) @@ -115,7 +98,7 @@ class StringList(CClass): if index < 0 or index >= length: raise IndexError else: - return cfunc.stringlist_iget(self, index) + return StringList.cNamespace().stringlist_iget(self, index) else: raise TypeError("Index should be integer type") @@ -125,7 +108,7 @@ class StringList(CClass): The 'in' check is based on string equality. """ - return cfunc.contains(self, s) + return StringList.cNamespace().contains(self, s) def contains(self, s): """ @@ -141,7 +124,7 @@ class StringList(CClass): """ The length of the list - used to support builtin len(). """ - return cfunc.stringlist_get_size(self) + return StringList.cNamespace().stringlist_get_size(self) def __str__(self): @@ -166,7 +149,7 @@ class StringList(CClass): Will raise IndexError if list is empty. """ if len(self): - return cfunc.pop(self) + return StringList.cNamespace().pop(self) else: raise IndexError("pop() failed - the list is empty") @@ -176,7 +159,7 @@ class StringList(CClass): Appends a new string @s to list. """ if isinstance(s, StringType): - cfunc.stringlist_append(self, s) + StringList.cNamespace().stringlist_append(self, s) else: sys.exit("Type mismatch") @@ -200,7 +183,7 @@ class StringList(CClass): Will return the last element in list. Raise IndexError if empty. """ if len(self): - return cfunc.last(self) + return StringList.cNamespace().last(self) else: raise IndexError("The list is empty") @@ -217,21 +200,25 @@ class StringList(CClass): 2 : util_strcmp_float() string comparison """ - cfunc.sort(self, cmp_flag) + StringList.cNamespace().sort(self, cmp_flag) + + def free(self): + StringList.cNamespace().free(self) CWrapper.registerType("stringlist", StringList) - +CWrapper.registerType("stringlist_obj", StringList.createPythonObject) +CWrapper.registerType("stringlist_ref", StringList.createCReference) cwrapper = CWrapper(UTIL_LIB) -cfunc = CWrapperNameSpace("StringList") -cfunc.stringlist_alloc = cwrapper.prototype("c_void_p stringlist_alloc_new( )") -cfunc.free = cwrapper.prototype("void stringlist_free( stringlist )") -cfunc.stringlist_append = cwrapper.prototype("void stringlist_append_copy( stringlist , char* )") -cfunc.stringlist_iget = cwrapper.prototype("char* stringlist_iget( stringlist , int )") -cfunc.stringlist_iget_copy = cwrapper.prototype("char* stringlist_iget_copy(stringlist, int)") -cfunc.stringlist_iset = cwrapper.prototype("void stringlist_iset_copy( stringlist , int , char* )") -cfunc.stringlist_get_size = cwrapper.prototype("int stringlist_get_size( stringlist )") -cfunc.contains = cwrapper.prototype("bool stringlist_contains(stringlist , char*)") -cfunc.sort = cwrapper.prototype("void stringlist_python_sort( stringlist , int)") -cfunc.pop = cwrapper.safe_prototype("char* stringlist_pop( stringlist )") -cfunc.last = cwrapper.safe_prototype("char* stringlist_get_last( stringlist )") + +StringList.cNamespace().stringlist_alloc = cwrapper.prototype("c_void_p stringlist_alloc_new( )") +StringList.cNamespace().free = cwrapper.prototype("void stringlist_free( stringlist )") +StringList.cNamespace().stringlist_append = cwrapper.prototype("void stringlist_append_copy( stringlist , char* )") +StringList.cNamespace().stringlist_iget = cwrapper.prototype("char* stringlist_iget( stringlist , int )") +StringList.cNamespace().stringlist_iget_copy = cwrapper.prototype("char* stringlist_iget_copy(stringlist, int)") +StringList.cNamespace().stringlist_iset = cwrapper.prototype("void stringlist_iset_copy( stringlist , int , char* )") +StringList.cNamespace().stringlist_get_size = cwrapper.prototype("int stringlist_get_size( stringlist )") +StringList.cNamespace().contains = cwrapper.prototype("bool stringlist_contains(stringlist , char*)") +StringList.cNamespace().sort = cwrapper.prototype("void stringlist_python_sort( stringlist , int)") +StringList.cNamespace().pop = cwrapper.safe_prototype("char* stringlist_pop( stringlist )") +StringList.cNamespace().last = cwrapper.safe_prototype("char* stringlist_get_last( stringlist )") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/substitution_list.py b/ThirdParty/Ert/devel/python/python/ert/util/substitution_list.py new file mode 100644 index 0000000000..380c3a34fc --- /dev/null +++ b/ThirdParty/Ert/devel/python/python/ert/util/substitution_list.py @@ -0,0 +1,46 @@ +from ert.cwrap import BaseCClass, CWrapper +from ert.util import UTIL_LIB + + +class SubstitutionList(BaseCClass): + def __init__(self): + c_ptr = SubstitutionList.cNamespace().alloc(0) + super(SubstitutionList, self).__init__(c_ptr) + + def __len__(self): + return SubstitutionList.cNamespace().size(self) + + def addItem(self, key, value, doc_string=""): + SubstitutionList.cNamespace().append_copy(self, key, value, doc_string) + + + def __getitem__(self, index): + if not isinstance(index, int): + raise IndexError("Index must be a number!") + + if index < 0 or index >= len(self): + raise IndexError("Index must be in the range: [%i, %i]" % (0, len(self) - 1)) + + key = SubstitutionList.cNamespace().get_key(self, index) + value = SubstitutionList.cNamespace().get_value(self, index) + doc_string = SubstitutionList.cNamespace().get_doc_string(self, index) + + return key, value, doc_string + + def free(self): + SubstitutionList.cNamespace().free(self) + +cwrapper = CWrapper(UTIL_LIB) +CWrapper.registerType("subst_list", SubstitutionList) +CWrapper.registerType("subst_list_obj", SubstitutionList.createPythonObject) +CWrapper.registerType("subst_list_ref", SubstitutionList.createCReference) + +SubstitutionList.cNamespace().alloc = cwrapper.prototype("c_void_p subst_list_alloc(c_void_p)") +SubstitutionList.cNamespace().free = cwrapper.prototype("void subst_list_free(subst_list)") + +SubstitutionList.cNamespace().size = cwrapper.prototype("int subst_list_get_size(subst_list)") +SubstitutionList.cNamespace().get_key = cwrapper.prototype("char* subst_list_iget_key(subst_list, int)") +SubstitutionList.cNamespace().get_value = cwrapper.prototype("char* subst_list_iget_value(subst_list, int)") +SubstitutionList.cNamespace().get_doc_string = cwrapper.prototype("char* subst_list_iget_doc_string(subst_list, int)") + +SubstitutionList.cNamespace().append_copy = cwrapper.prototype("void subst_list_append_copy(subst_list, char*, char*, char*)") \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/python/ert/util/test_area.py b/ThirdParty/Ert/devel/python/python/ert/util/test_area.py index b3fb3767c7..a4316686be 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/test_area.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/test_area.py @@ -14,34 +14,35 @@ # See the GNU General Public License at # for more details. -from ert.cwrap import clib, CClass, CWrapper, CWrapperNameSpace +from ert.cwrap import clib, BaseCClass, CWrapper lib = clib.ert_load("libtest_util.so") -class TestArea(CClass): +class TestArea(BaseCClass): def __init__(self, test_name, store_area=False): - c_ptr = cfunc.test_area_alloc(test_name, store_area) - if not c_ptr: - raise Exception("Failed to create TestArea instance") + c_ptr = TestArea.cNamespace().test_area_alloc(test_name, store_area) + super(TestArea, self).__init__(c_ptr) - self.init_cobj(c_ptr, cfunc.free) def install_file( self, filename): - cfunc.install_file(self, filename) + TestArea.cNamespace().install_file(self, filename) def copy_directory( self, directory): - cfunc.copy_directory(self, directory) + TestArea.cNamespace().copy_directory(self, directory) def copy_directory_content( self, directory): - cfunc.copy_directory_content(self, directory) + TestArea.cNamespace().copy_directory_content(self, directory) def copy_file( self, filename): - cfunc.copy_file(self, filename) + TestArea.cNamespace().copy_file(self, filename) + + def free(self): + TestArea.cNamespace().free(self) class TestAreaContext(object): @@ -63,15 +64,14 @@ class TestAreaContext(object): -CWrapper.registerType("test_area", TestArea) - cwrapper = CWrapper(lib) +CWrapper.registerType("test_area", TestArea) +CWrapper.registerType("test_area_obj", TestArea.createPythonObject) +CWrapper.registerType("test_area_ref", TestArea.createCReference) -cfunc = CWrapperNameSpace("TestArea") - -cfunc.test_area_alloc = cwrapper.prototype("c_void_p test_work_area_alloc( char* , bool)") -cfunc.free = cwrapper.prototype("void test_work_area_free( test_area )") -cfunc.install_file = cwrapper.prototype("void test_work_area_install_file( test_area , char* )") -cfunc.copy_directory = cwrapper.prototype("void test_work_area_copy_directory( test_area , char* )") -cfunc.copy_file = cwrapper.prototype("void test_work_area_copy_file( test_area , char* )") -cfunc.copy_directory_content = cwrapper.prototype("void test_work_area_copy_directory_content( test_area , char* )") +TestArea.cNamespace().test_area_alloc = cwrapper.prototype("c_void_p test_work_area_alloc( char* , bool)") +TestArea.cNamespace().free = cwrapper.prototype("void test_work_area_free( test_area )") +TestArea.cNamespace().install_file = cwrapper.prototype("void test_work_area_install_file( test_area , char* )") +TestArea.cNamespace().copy_directory = cwrapper.prototype("void test_work_area_copy_directory( test_area , char* )") +TestArea.cNamespace().copy_file = cwrapper.prototype("void test_work_area_copy_file( test_area , char* )") +TestArea.cNamespace().copy_directory_content = cwrapper.prototype("void test_work_area_copy_directory_content( test_area , char* )") diff --git a/ThirdParty/Ert/devel/python/python/ert/util/tvector.py b/ThirdParty/Ert/devel/python/python/ert/util/tvector.py index 1e0c6e4951..680a0e746b 100644 --- a/ThirdParty/Ert/devel/python/python/ert/util/tvector.py +++ b/ThirdParty/Ert/devel/python/python/ert/util/tvector.py @@ -45,14 +45,14 @@ from types import IntType, SliceType import ctypes import numpy -from ert.cwrap import CWrapper, CClass, CFILE, CWrapperNameSpace +from ert.cwrap import CWrapper, CFILE, BaseCClass from ert.util import UTIL_LIB, ctime - -class TVector(CClass): +#TVector takes advantage of the fact that self.cNamespace belongs to the inheriting class +class TVector(BaseCClass): @classmethod def strided_copy( cls , obj , slice_range ): @@ -73,25 +73,14 @@ class TVector(CClass): """ (start , stop , step) = slice_range.indices( obj.size ) if stop > start: - new_obj = TVector.__new__( cls ) - c_ptr = cls.cstrided_copy( obj , start , stop , step ) - new_obj.init_cobj( c_ptr , new_obj.free ) - return new_obj + return cls.cNamespace().strided_copy(obj, start, stop, step) else: return None @classmethod def __copy__( cls , obj ): - new_obj = TVector.__new__( cls ) - c_ptr = cls.alloc_copy( obj ) - new_obj.init_cobj( c_ptr , new_obj.free ) - return new_obj - - - def __new__( cls , **kwargs): - obj = object.__new__( cls ) - return obj + return cls.cNamespace().alloc_copy(obj) def copy( self ): @@ -106,14 +95,13 @@ class TVector(CClass): new = self.copy( ) return new - def __init__( self , default_value = 0): + def __init__(self, default_value = 0, initial_size = 0): """ Creates a new TVector instance. """ - init_size = 0 - c_ptr = self.alloc( init_size , default_value ) - self.init_cobj( c_ptr , self.free ) - self.element_size = self.get_element_size( self ) + c_pointer = self.cNamespace().alloc(initial_size, default_value) + super(TVector, self).__init__(c_pointer) + self.element_size = self.cNamespace().element_size( self ) def str_data( self , width , index1 , index2 , fmt): @@ -187,7 +175,7 @@ class TVector(CClass): if index < 0 or index >= length: raise IndexError else: - return self.iget( self , index ) + return self.cNamespace().iget( self , index ) elif isinstance( index , SliceType ): return self.strided_copy( self , index ) else: @@ -198,7 +186,7 @@ class TVector(CClass): Implements write [] operator - @index must be integer. """ if isinstance( index , IntType): - self.iset( self, index , value ) + self.cNamespace().iset( self, index , value ) else: raise TypeError("Index should be integer type") @@ -227,15 +215,15 @@ class TVector(CClass): if self.size == delta.size: # This is vector + vector operation. if not add: - self.scale( delta , -1 ) - self.inplace_add( self , delta ) + self.cNamespace().scale( delta , -1 ) + self.cNamespace().inplace_add( self , delta ) else: raise ValueError("Incompatible sizes for add self:%d other:%d" % (self.size , delta.size)) else: if isinstance( delta , int ) or isinstance( delta, float): if not add: delta *= -1 - self.shift( self , delta ) + self.cNamespace().shift( self , delta ) else: raise TypeError("delta has wrong type:%s " % type(delta)) @@ -259,12 +247,12 @@ class TVector(CClass): if type(self) == type(factor): # This is vector * vector operation. if self.size == factor.size: - self.inplace_mul( self , factor ) + self.cNamespace().inplace_mul( self , factor ) else: raise ValueError("Incompatible sizes for mul self:%d other:%d" % (self.size , factor.size)) else: if isinstance( factor , int ) or isinstance( factor, float): - self.scale( self , factor ) + self.cNamespace().scale( self , factor ) else: raise TypeError("factor has wrong type:%s " % type(factor)) @@ -325,7 +313,7 @@ class TVector(CClass): def __div__(self , divisor): if isinstance( divisor , int ) or isinstance( divisor , float): copy = self.__copy__( self ) - copy.div( copy , divisor ) + copy.cNamespace().div( copy , divisor ) return copy else: raise TypeError("Divisor has wrong type:%s" % type( divisor )) @@ -357,10 +345,10 @@ class TVector(CClass): """ if type(self) == type(value): # This is a copy operation - self.memcpy( self , value ) + self.cNamespace().memcpy( self , value ) else: if isinstance( value , int ) or isinstance( value, float): - self.cassign( self , value ) + self.cNamespace().assign( self , value ) else: raise TypeError("Value has wrong type") @@ -368,7 +356,7 @@ class TVector(CClass): """ The number of elements in the vector. """ - return self.get_size( self ) + return self.cNamespace().size( self ) def printf( self , fmt = None , name = None , stream = sys.stdout ): @@ -379,7 +367,7 @@ class TVector(CClass): cfile = CFILE( stream ) if not fmt: fmt = self.def_fmt - self.fprintf(self , cfile , name , fmt) + self.cNamespace().fprintf(self , cfile , name , fmt) @property def size( self ): @@ -390,33 +378,33 @@ class TVector(CClass): @property def max( self ): - if self.get_size( self ) > 0: - return self.get_max( self ) + if self.cNamespace().size( self ) > 0: + return self.cNamespace().get_max( self ) else: raise IndexError @property def min( self ): - if self.get_size( self ) > 0: - return self.get_min( self ) + if self.cNamespace().size( self ) > 0: + return self.cNamespace().get_min( self ) else: raise IndexError def min_index( self , reverse = False ): - if self.get_size( self ) > 0: - return self.get_min_index( self , reverse ) + if self.cNamespace().size( self ) > 0: + return self.cNamespace().get_min_index( self , reverse ) else: raise IndexError def max_index( self , reverse = False ): - if self.get_size( self ) > 0: - return self.get_max_index( self , reverse ) + if self.cNamespace().size( self ) > 0: + return self.cNamespace().get_max_index( self , reverse ) else: raise IndexError def append( self , value ): - self.cappend( self , value ) + self.cNamespace().append( self , value ) def del_block( self , index , block_size ): """ @@ -424,43 +412,46 @@ class TVector(CClass): After the removal data will be left shifted. """ - self.idel_block( self , index , block_size ) + self.cNamespace().idel_block( self , index , block_size ) def sort( self ): """ Sort the vector inplace in increasing numerical order. """ - self.csort( self ) + self.cNamespace().sort( self ) def rsort( self ): """ Sort the vector inplace in reverse (decreasing) numerical order. """ - self.crsort( self ) + self.cNamespace().rsort( self ) def clear(self): - self.cclear( self ) + self.cNamespace().reset( self ) def safe_iget( self , index): - return self.csafe_iget( self , index ) + return self.cNamespace().safe_iget( self , index ) def set_read_only( self , read_only ): - self.set_read_only( self , read_only ) + self.cNamespace().set_read_only( self , read_only ) def get_read_only( self ): - return self.get_read_only( self ) + return self.cNamespace().get_read_only( self ) read_only = property( get_read_only , set_read_only ) def set_default( self , value ): - self.cset_default( self , value ) + self.cNamespace().set_default( self , value ) def get_default( self ): - return self.cget_default( self ) + return self.cNamespace().get_default( self ) default = property( get_default , set_default ) + def free(self): + self.cNamespace().free(self) + # The numpy_copy() method goes thorugh a bit of hoops to get the # memory ownership correct: # @@ -485,7 +476,7 @@ class TVector(CClass): The returned numpy copy is a true copy, and does not share any storage with the vector instance. """ - data_ptr = self.data_ptr( self ) + data_ptr = self.cNamespace().data_ptr( self ) buffer_size = self.size * self.element_size buffer = buffer_from_ptr( data_ptr , buffer_size ) view = numpy.frombuffer( buffer , self.numpy_dtype ) @@ -500,97 +491,13 @@ class TVector(CClass): # invoke the ugly cls.initialized flag. class DoubleVector(TVector): - initialized = False - - - - def __new__( cls , **kwargs ): - if not cls.initialized: - cls.csort = cfunc.double_vector_sort - cls.crsort = cfunc.double_vector_rsort - cls.alloc = cfunc.double_vector_alloc - cls.alloc_copy = cfunc.double_vector_alloc_copy - # cls.free = cfunc.double_vector_free - cls.get_size = cfunc.double_vector_size - cls.iget = cfunc.double_vector_iget - cls.iset = cfunc.double_vector_iset - cls.fprintf = cfunc.double_vector_fprintf - cls.cappend = cfunc.double_vector_append - cls.idel_block = cfunc.double_vector_idel_block - cls.cclear = cfunc.double_vector_reset - cls.cstrided_copy = cfunc.double_vector_strided_copy - cls.csafe_iget = cfunc.double_vector_safe_iget - cls.set_read_only = cfunc.double_vector_set_read_only - cls.get_read_only = cfunc.double_vector_get_read_only - cls.get_max = cfunc.double_vector_get_max - cls.get_min = cfunc.double_vector_get_min - cls.get_max_index = cfunc.double_vector_get_max_index - cls.get_min_index = cfunc.double_vector_get_min_index - cls.shift = cfunc.double_vector_shift - cls.scale = cfunc.double_vector_scale - cls.div = cfunc.double_vector_div - cls.inplace_add = cfunc.double_vector_inplace_add - cls.inplace_mul = cfunc.double_vector_inplace_mul - cls.cassign = cfunc.double_vector_assign - cls.memcpy = cfunc.double_vector_memcpy - cls.cset_default = cfunc.double_vector_set_default - cls.cget_default = cfunc.double_vector_get_default - cls.alloc_data_copy = cfunc.double_vector_alloc_data_copy - cls.get_element_size = cfunc.double_vector_element_size - cls.data_ptr = cfunc.double_vector_data_ptr - cls.numpy_dtype = numpy.float64 - cls.def_fmt = "%8.4f" - cls.initialized = True - - obj = TVector.__new__( cls , **kwargs ) - return obj - + def __init__(self, default_value=0, initial_size=0): + super(DoubleVector, self).__init__(default_value, initial_size) class BoolVector(TVector): - initialized = False - - def __new__( cls , **kwargs ): - if not cls.initialized: - cls.csort = cfunc.bool_vector_sort - cls.crsort = cfunc.bool_vector_rsort - cls.alloc = cfunc.bool_vector_alloc - cls.alloc_copy = cfunc.bool_vector_alloc_copy - # cls.free = cfunc.bool_vector_free - cls.get_size = cfunc.bool_vector_size - cls.iget = cfunc.bool_vector_iget - cls.iset = cfunc.bool_vector_iset - cls.fprintf = cfunc.bool_vector_fprintf - cls.cappend = cfunc.bool_vector_append - cls.idel_block = cfunc.bool_vector_idel_block - cls.cclear = cfunc.bool_vector_reset - cls.cstrided_copy = cfunc.bool_vector_strided_copy - cls.csafe_iget = cfunc.bool_vector_safe_iget - cls.set_read_only = cfunc.bool_vector_set_read_only - cls.get_read_only = cfunc.bool_vector_get_read_only - cls.get_max = cfunc.bool_vector_get_max - cls.get_min = cfunc.bool_vector_get_min - cls.get_max_index = cfunc.bool_vector_get_max_index - cls.get_min_index = cfunc.bool_vector_get_min_index - cls.shift = cfunc.bool_vector_shift - cls.scale = cfunc.bool_vector_scale - cls.div = cfunc.bool_vector_div - cls.inplace_add = cfunc.bool_vector_inplace_add - cls.inplace_mul = cfunc.bool_vector_inplace_mul - cls.cassign = cfunc.bool_vector_assign - cls.memcpy = cfunc.bool_vector_memcpy - cls.cset_default = cfunc.bool_vector_set_default - cls.cget_default = cfunc.bool_vector_get_default - cls.alloc_data_copy = cfunc.bool_vector_alloc_data_copy - cls.get_element_size = cfunc.bool_vector_element_size - cls.data_ptr = cfunc.bool_vector_data_ptr - cls.numpy_dtype = numpy.bool - cls.def_fmt = "%8d" - cls.initialized = True - - obj = TVector.__new__( cls , **kwargs) - return obj - + def __init__(self, default_value=0, initial_size=0): + super(BoolVector, self).__init__(default_value, initial_size) @classmethod def active_mask(cls , range_string): @@ -607,22 +514,17 @@ class BoolVector(TVector): The empty list will evaluate to false """ - new_obj = BoolVector.__new__(cls) - c_ptr = cfunc.create_active_mask( range_string ) - new_obj.init_cobj( c_ptr , new_obj.free ) - return new_obj + return cls.cNamespace().create_active_mask(range_string) @classmethod def create_from_list(cls, size, source_list): """Allocates a bool vector from a Python list""" - new_obj = BoolVector.__new__(cls) - c_ptr = cfunc.bool_vector_alloc(size , False) - for index in source_list: - cfunc.bool_vector_iset(c_ptr, index, True) + bool_vector = BoolVector(False, size) - #c_ptr = cfunc.bool_vector_data_ptr(mask) - new_obj.init_cobj( c_ptr , new_obj.free ) - return new_obj + for index in range(len(source_list)): + bool_vector[index] = source_list[index] + + return bool_vector @@ -630,48 +532,10 @@ class BoolVector(TVector): class IntVector(TVector): - initialized = False - def __new__( cls , **kwargs ): - if not cls.initialized: - cls.csort = cfunc.int_vector_sort - cls.crsort = cfunc.int_vector_rsort - cls.alloc = cfunc.int_vector_alloc - cls.alloc_copy = cfunc.int_vector_alloc_copy - # cls.free = cfunc.int_vector_free - cls.get_size = cfunc.int_vector_size - cls.iget = cfunc.int_vector_iget - cls.iset = cfunc.int_vector_iset - cls.fprintf = cfunc.int_vector_fprintf - cls.cappend = cfunc.int_vector_append - cls.idel_block = cfunc.int_vector_idel_block - cls.cclear = cfunc.int_vector_reset - cls.cstrided_copy = cfunc.int_vector_strided_copy - cls.csafe_iget = cfunc.int_vector_safe_iget - cls.set_read_only = cfunc.int_vector_set_read_only - cls.get_read_only = cfunc.int_vector_get_read_only - cls.get_max = cfunc.int_vector_get_max - cls.get_min = cfunc.int_vector_get_min - cls.get_max_index = cfunc.int_vector_get_max_index - cls.get_min_index = cfunc.int_vector_get_min_index - cls.shift = cfunc.int_vector_shift - cls.scale = cfunc.int_vector_scale - cls.div = cfunc.int_vector_div - cls.inplace_add = cfunc.int_vector_inplace_add - cls.inplace_mul = cfunc.int_vector_inplace_mul - cls.cassign = cfunc.int_vector_assign - cls.memcpy = cfunc.int_vector_memcpy - cls.cset_default = cfunc.int_vector_set_default - cls.cget_default = cfunc.int_vector_get_default - cls.alloc_data_copy = cfunc.int_vector_alloc_data_copy - cls.data_ptr = cfunc.int_vector_data_ptr - cls.get_element_size = cfunc.int_vector_element_size - cls.numpy_dtype = numpy.int32 - cls.def_fmt = "%d" - cls.initialized = True - obj = TVector.__new__( cls , **kwargs) - return obj + def __init__(self, default_value=0, initial_size=0): + super(IntVector, self).__init__(default_value, initial_size) @classmethod def active_list(cls , range_string): @@ -688,55 +552,12 @@ class IntVector(TVector): The empty list will evaluate to false """ - new_obj = IntVector.__new__(cls) - c_ptr = cfunc.create_active_list( range_string ) - new_obj.init_cobj( c_ptr , new_obj.free ) - return new_obj + return cls.cNamespace().create_active_list(range_string) class TimeVector(TVector): - initialized = False - - def __new__( cls , **kwargs ): - if not cls.initialized: - cls.csort = cfunc.time_t_vector_sort - cls.crsort = cfunc.time_t_vector_rsort - cls.alloc = cfunc.time_t_vector_alloc - cls.alloc_copy = cfunc.time_t_vector_alloc_copy - # cls.free = cfunc.time_t_vector_free - cls.get_size = cfunc.time_t_vector_size - cls.iget = cfunc.time_t_vector_iget - cls.iset = cfunc.time_t_vector_iset - cls.fprintf = cfunc.time_t_vector_fprintf - cls.cappend = cfunc.time_t_vector_append - cls.idel_block = cfunc.time_t_vector_idel_block - cls.cclear = cfunc.time_t_vector_reset - cls.cstrided_copy = cfunc.time_t_vector_strided_copy - cls.csafe_iget = cfunc.time_t_vector_safe_iget - cls.set_read_only = cfunc.time_t_vector_set_read_only - cls.get_read_only = cfunc.time_t_vector_get_read_only - cls.get_max = cfunc.time_t_vector_get_max - cls.get_min = cfunc.time_t_vector_get_min - cls.get_max_index = cfunc.time_t_vector_get_max_index - cls.get_min_index = cfunc.time_t_vector_get_min_index - cls.shift = cfunc.time_t_vector_shift - cls.scale = cfunc.time_t_vector_scale - cls.div = cfunc.time_t_vector_div - cls.inplace_add = cfunc.time_t_vector_inplace_add - cls.inplace_mul = cfunc.time_t_vector_inplace_mul - cls.cassign = cfunc.time_t_vector_assign - cls.memcpy = cfunc.time_t_vector_memcpy - cls.cset_default = cfunc.time_t_vector_set_default - cls.cget_default = cfunc.time_t_vector_get_default - cls.alloc_data_copy = cfunc.time_t_vector_alloc_data_copy - cls.get_element_size = cfunc.time_t_vector_element_size - cls.data_ptr = cfunc.time_t_vector_data_ptr - cls.numpy_dtype = numpy.float64 - cls.def_fmt = "%8.4f" - cls.initialized = True - - obj = TVector.__new__( cls , **kwargs ) - return obj + def __init__(self, default_value=0, initial_size=0): + super(TimeVector, self).__init__(default_value, initial_size) ################################################################# @@ -745,159 +566,168 @@ buffer_from_ptr = ctypes.pythonapi.PyBuffer_FromMemory buffer_from_ptr.restype = ctypes.py_object buffer_from_ptr.argtypes = [ ctypes.c_void_p , ctypes.c_long ] -CWrapper.registerType( "double_vector" , DoubleVector ) -CWrapper.registerType( "int_vector" , IntVector ) -CWrapper.registerType( "bool_vector" , BoolVector ) -CWrapper.registerType( "time_t_vector" , TimeVector ) +CWrapper.registerType("double_vector", DoubleVector) +CWrapper.registerType("double_vector_obj", DoubleVector.createPythonObject) +CWrapper.registerType("double_vector_ref", DoubleVector.createCReference) + +CWrapper.registerType("int_vector", IntVector) +CWrapper.registerType("int_vector_obj", IntVector.createPythonObject) +CWrapper.registerType("int_vector_ref", IntVector.createCReference) + +CWrapper.registerType("bool_vector", BoolVector) +CWrapper.registerType("bool_vector_obj", BoolVector.createPythonObject) +CWrapper.registerType("bool_vector_ref", BoolVector.createCReference) + +CWrapper.registerType("time_t_vector", TimeVector) +CWrapper.registerType("time_t_vector_obj", TimeVector.createPythonObject) +CWrapper.registerType("time_t_vector_ref", TimeVector.createCReference) cwrapper = CWrapper(UTIL_LIB) -cfunc = CWrapperNameSpace("tvector") -BoolVector.free = cwrapper.prototype("void bool_vector_free( bool_vector )") -DoubleVector.free = cwrapper.prototype("void double_vector_free( double_vector )") -IntVector.free = cwrapper.prototype("void int_vector_free( int_vector )") -TimeVector.free = cwrapper.prototype("void time_t_vector_free( time_t_vector )") - -cfunc.double_vector_alloc = cwrapper.prototype("c_void_p double_vector_alloc( int , double )") -cfunc.double_vector_alloc_copy = cwrapper.prototype("c_void_p double_vector_alloc_copy( double_vector )") -cfunc.double_vector_strided_copy = cwrapper.prototype("c_void_p double_vector_alloc_strided_copy( double_vector , int , int , int)") -# cfunc.double_vector_free = cwrapper.prototype("void double_vector_free( double_vector )") -cfunc.double_vector_iget = cwrapper.prototype("double double_vector_iget( double_vector , int )") -cfunc.double_vector_safe_iget = cwrapper.prototype("double double_vector_safe_iget( int_vector , int )") -cfunc.double_vector_iset = cwrapper.prototype("double double_vector_iset( double_vector , int , double)") -cfunc.double_vector_size = cwrapper.prototype("int double_vector_size( double_vector )") -cfunc.double_vector_append = cwrapper.prototype("void double_vector_append( double_vector , double )") -cfunc.double_vector_idel_block = cwrapper.prototype("void double_vector_idel_block( double_vector , int , int )") -cfunc.double_vector_fprintf = cwrapper.prototype("void double_vector_fprintf( double_vector , FILE , char* , char*)") -cfunc.double_vector_sort = cwrapper.prototype("void double_vector_sort( double_vector )") -cfunc.double_vector_rsort = cwrapper.prototype("void double_vector_rsort( double_vector )") -cfunc.double_vector_reset = cwrapper.prototype("void double_vector_reset( double_vector )") -cfunc.double_vector_get_read_only = cwrapper.prototype("bool double_vector_get_read_only( double_vector )") -cfunc.double_vector_set_read_only = cwrapper.prototype("void double_vector_set_read_only( double_vector , bool )") -cfunc.double_vector_get_max = cwrapper.prototype("double double_vector_get_max( double_vector )") -cfunc.double_vector_get_min = cwrapper.prototype("double double_vector_get_min( double_vector )") -cfunc.double_vector_get_max_index = cwrapper.prototype("int double_vector_get_max_index( double_vector , bool)") -cfunc.double_vector_get_min_index = cwrapper.prototype("int double_vector_get_min_index( double_vector , bool)") -cfunc.double_vector_shift = cwrapper.prototype("void double_vector_shift( double_vector , double )") -cfunc.double_vector_scale = cwrapper.prototype("void double_vector_scale( double_vector , double )") -cfunc.double_vector_div = cwrapper.prototype("void double_vector_div( double_vector , double )") -cfunc.double_vector_inplace_add = cwrapper.prototype("void double_vector_inplace_add( double_vector , double_vector )") -cfunc.double_vector_inplace_mul = cwrapper.prototype("void double_vector_inplace_mul( double_vector , double_vector )") -cfunc.double_vector_assign = cwrapper.prototype("void double_vector_set_all( double_vector , double)") -cfunc.double_vector_memcpy = cwrapper.prototype("void double_vector_memcpy(double_vector , double_vector )") -cfunc.double_vector_set_default = cwrapper.prototype("void double_vector_set_default( double_vector , double)") -cfunc.double_vector_get_default = cwrapper.prototype("double double_vector_get_default( double_vector )") -cfunc.double_vector_alloc_data_copy = cwrapper.prototype("double* double_vector_alloc_data_copy( double_vector )") -cfunc.double_vector_data_ptr = cwrapper.prototype("double* double_vector_get_ptr( double_vector )") -cfunc.double_vector_element_size = cwrapper.prototype("int double_vector_element_size( double_vector )") +DoubleVector.cNamespace().alloc = cwrapper.prototype("c_void_p double_vector_alloc( int , double )") +DoubleVector.cNamespace().alloc_copy = cwrapper.prototype("double_vector_obj double_vector_alloc_copy( double_vector )") +DoubleVector.cNamespace().strided_copy = cwrapper.prototype("double_vector_obj double_vector_alloc_strided_copy( double_vector , int , int , int)") +DoubleVector.cNamespace().free = cwrapper.prototype("void double_vector_free( double_vector )") +DoubleVector.cNamespace().iget = cwrapper.prototype("double double_vector_iget( double_vector , int )") +DoubleVector.cNamespace().safe_iget = cwrapper.prototype("double double_vector_safe_iget( int_vector , int )") +DoubleVector.cNamespace().iset = cwrapper.prototype("double double_vector_iset( double_vector , int , double)") +DoubleVector.cNamespace().size = cwrapper.prototype("int double_vector_size( double_vector )") +DoubleVector.cNamespace().append = cwrapper.prototype("void double_vector_append( double_vector , double )") +DoubleVector.cNamespace().idel_block = cwrapper.prototype("void double_vector_idel_block( double_vector , int , int )") +DoubleVector.cNamespace().fprintf = cwrapper.prototype("void double_vector_fprintf( double_vector , FILE , char* , char*)") +DoubleVector.cNamespace().sort = cwrapper.prototype("void double_vector_sort( double_vector )") +DoubleVector.cNamespace().rsort = cwrapper.prototype("void double_vector_rsort( double_vector )") +DoubleVector.cNamespace().reset = cwrapper.prototype("void double_vector_reset( double_vector )") +DoubleVector.cNamespace().get_read_only = cwrapper.prototype("bool double_vector_get_read_only( double_vector )") +DoubleVector.cNamespace().set_read_only = cwrapper.prototype("void double_vector_set_read_only( double_vector , bool )") +DoubleVector.cNamespace().get_max = cwrapper.prototype("double double_vector_get_max( double_vector )") +DoubleVector.cNamespace().get_min = cwrapper.prototype("double double_vector_get_min( double_vector )") +DoubleVector.cNamespace().get_max_index = cwrapper.prototype("int double_vector_get_max_index( double_vector , bool)") +DoubleVector.cNamespace().get_min_index = cwrapper.prototype("int double_vector_get_min_index( double_vector , bool)") +DoubleVector.cNamespace().shift = cwrapper.prototype("void double_vector_shift( double_vector , double )") +DoubleVector.cNamespace().scale = cwrapper.prototype("void double_vector_scale( double_vector , double )") +DoubleVector.cNamespace().div = cwrapper.prototype("void double_vector_div( double_vector , double )") +DoubleVector.cNamespace().inplace_add = cwrapper.prototype("void double_vector_inplace_add( double_vector , double_vector )") +DoubleVector.cNamespace().inplace_mul = cwrapper.prototype("void double_vector_inplace_mul( double_vector , double_vector )") +DoubleVector.cNamespace().assign = cwrapper.prototype("void double_vector_set_all( double_vector , double)") +DoubleVector.cNamespace().memcpy = cwrapper.prototype("void double_vector_memcpy(double_vector , double_vector )") +DoubleVector.cNamespace().set_default = cwrapper.prototype("void double_vector_set_default( double_vector , double)") +DoubleVector.cNamespace().get_default = cwrapper.prototype("double double_vector_get_default( double_vector )") +DoubleVector.cNamespace().alloc_data_copy = cwrapper.prototype("double* double_vector_alloc_data_copy( double_vector )") +DoubleVector.cNamespace().data_ptr = cwrapper.prototype("double* double_vector_get_ptr( double_vector )") +DoubleVector.cNamespace().element_size = cwrapper.prototype("int double_vector_element_size( double_vector )") -cfunc.int_vector_alloc_copy = cwrapper.prototype("c_void_p int_vector_alloc_copy( int_vector )") -cfunc.int_vector_alloc = cwrapper.prototype("c_void_p int_vector_alloc( int , int )") -cfunc.int_vector_strided_copy = cwrapper.prototype("c_void_p int_vector_alloc_strided_copy( int_vector , int , int , int)") -# cfunc.int_vector_free = cwrapper.prototype("void int_vector_free( int_vector )") -cfunc.int_vector_iget = cwrapper.prototype("int int_vector_iget( int_vector , int )") -cfunc.int_vector_safe_iget = cwrapper.prototype("int int_vector_safe_iget( int_vector , int )") -cfunc.int_vector_iset = cwrapper.prototype("int int_vector_iset( int_vector , int , int)") -cfunc.int_vector_size = cwrapper.prototype("int int_vector_size( int_vector )") -cfunc.int_vector_append = cwrapper.prototype("void int_vector_append( int_vector , int )") -cfunc.int_vector_idel_block = cwrapper.prototype("void int_vector_idel_block( int_vector , int , int )") -cfunc.int_vector_fprintf = cwrapper.prototype("void int_vector_fprintf( int_vector , FILE , char* , char*)") -cfunc.int_vector_sort = cwrapper.prototype("void int_vector_sort( int_vector )") -cfunc.int_vector_rsort = cwrapper.prototype("void int_vector_rsort( int_vector )") -cfunc.int_vector_reset = cwrapper.prototype("void int_vector_reset( int_vector )") -cfunc.int_vector_set_read_only = cwrapper.prototype("void int_vector_set_read_only( int_vector , bool )") -cfunc.int_vector_get_read_only = cwrapper.prototype("bool int_vector_get_read_only( int_vector )") -cfunc.int_vector_get_max = cwrapper.prototype("int int_vector_get_max( int_vector )") -cfunc.int_vector_get_min = cwrapper.prototype("int int_vector_get_min( int_vector )") -cfunc.int_vector_get_max_index = cwrapper.prototype("int int_vector_get_max_index( int_vector , bool)") -cfunc.int_vector_get_min_index = cwrapper.prototype("int int_vector_get_min_index( int_vector , bool)") -cfunc.int_vector_shift = cwrapper.prototype("void int_vector_shift( int_vector , int )") -cfunc.int_vector_scale = cwrapper.prototype("void int_vector_scale( int_vector , int )") -cfunc.int_vector_div = cwrapper.prototype("void int_vector_div( int_vector , int )") -cfunc.int_vector_inplace_add = cwrapper.prototype("void int_vector_inplace_add( int_vector , int_vector )") -cfunc.int_vector_inplace_mul = cwrapper.prototype("void int_vector_inplace_mul( int_vector , int_vector )") -cfunc.int_vector_assign = cwrapper.prototype("void int_vector_set_all( int_vector , int)") -cfunc.int_vector_memcpy = cwrapper.prototype("void int_vector_memcpy(int_vector , int_vector )") -cfunc.int_vector_set_default = cwrapper.prototype("void int_vector_set_default( int_vector , int)") -cfunc.int_vector_get_default = cwrapper.prototype("int int_vector_get_default( int_vector )") -cfunc.int_vector_alloc_data_copy = cwrapper.prototype("int* int_vector_alloc_data_copy( int_vector )") -cfunc.int_vector_data_ptr = cwrapper.prototype("int* int_vector_get_ptr( int_vector )") -cfunc.int_vector_element_size = cwrapper.prototype("int int_vector_element_size( int_vector )") +IntVector.cNamespace().alloc = cwrapper.prototype("c_void_p int_vector_alloc( int , int )") +IntVector.cNamespace().alloc_copy = cwrapper.prototype("int_vector_obj int_vector_alloc_copy( int_vector )") +IntVector.cNamespace().strided_copy = cwrapper.prototype("int_vector_obj int_vector_alloc_strided_copy( int_vector , int , int , int)") +IntVector.cNamespace().free = cwrapper.prototype("void int_vector_free( int_vector )") +IntVector.cNamespace().iget = cwrapper.prototype("int int_vector_iget( int_vector , int )") +IntVector.cNamespace().safe_iget = cwrapper.prototype("int int_vector_safe_iget( int_vector , int )") +IntVector.cNamespace().iset = cwrapper.prototype("int int_vector_iset( int_vector , int , int)") +IntVector.cNamespace().size = cwrapper.prototype("int int_vector_size( int_vector )") +IntVector.cNamespace().append = cwrapper.prototype("void int_vector_append( int_vector , int )") +IntVector.cNamespace().idel_block = cwrapper.prototype("void int_vector_idel_block( int_vector , int , int )") +IntVector.cNamespace().fprintf = cwrapper.prototype("void int_vector_fprintf( int_vector , FILE , char* , char*)") +IntVector.cNamespace().sort = cwrapper.prototype("void int_vector_sort( int_vector )") +IntVector.cNamespace().rsort = cwrapper.prototype("void int_vector_rsort( int_vector )") +IntVector.cNamespace().reset = cwrapper.prototype("void int_vector_reset( int_vector )") +IntVector.cNamespace().set_read_only = cwrapper.prototype("void int_vector_set_read_only( int_vector , bool )") +IntVector.cNamespace().get_read_only = cwrapper.prototype("bool int_vector_get_read_only( int_vector )") +IntVector.cNamespace().get_max = cwrapper.prototype("int int_vector_get_max( int_vector )") +IntVector.cNamespace().get_min = cwrapper.prototype("int int_vector_get_min( int_vector )") +IntVector.cNamespace().get_max_index = cwrapper.prototype("int int_vector_get_max_index( int_vector , bool)") +IntVector.cNamespace().get_min_index = cwrapper.prototype("int int_vector_get_min_index( int_vector , bool)") +IntVector.cNamespace().shift = cwrapper.prototype("void int_vector_shift( int_vector , int )") +IntVector.cNamespace().scale = cwrapper.prototype("void int_vector_scale( int_vector , int )") +IntVector.cNamespace().div = cwrapper.prototype("void int_vector_div( int_vector , int )") +IntVector.cNamespace().inplace_add = cwrapper.prototype("void int_vector_inplace_add( int_vector , int_vector )") +IntVector.cNamespace().inplace_mul = cwrapper.prototype("void int_vector_inplace_mul( int_vector , int_vector )") +IntVector.cNamespace().assign = cwrapper.prototype("void int_vector_set_all( int_vector , int)") +IntVector.cNamespace().memcpy = cwrapper.prototype("void int_vector_memcpy(int_vector , int_vector )") +IntVector.cNamespace().set_default = cwrapper.prototype("void int_vector_set_default( int_vector , int)") +IntVector.cNamespace().get_default = cwrapper.prototype("int int_vector_get_default( int_vector )") +IntVector.cNamespace().alloc_data_copy = cwrapper.prototype("int* int_vector_alloc_data_copy( int_vector )") +IntVector.cNamespace().data_ptr = cwrapper.prototype("int* int_vector_get_ptr( int_vector )") +IntVector.cNamespace().element_size = cwrapper.prototype("int int_vector_element_size( int_vector )") + +IntVector.cNamespace().create_active_list = cwrapper.prototype("int_vector_obj string_util_alloc_active_list( char* )") -cfunc.bool_vector_alloc_copy = cwrapper.prototype("c_void_p bool_vector_alloc_copy( bool_vector )") -cfunc.bool_vector_alloc = cwrapper.prototype("c_void_p bool_vector_alloc( int , bool )") -cfunc.bool_vector_strided_copy = cwrapper.prototype("c_void_p bool_vector_alloc_strided_copy( bool_vector , bool , bool , bool)") -# cfunc.bool_vector_free = cwrapper.prototype("void bool_vector_free( bool_vector )") -cfunc.bool_vector_iget = cwrapper.prototype("bool bool_vector_iget( bool_vector , bool )") -cfunc.bool_vector_safe_iget = cwrapper.prototype("bool bool_vector_safe_iget( bool_vector , bool )") -cfunc.bool_vector_iset = cwrapper.prototype("bool bool_vector_iset( bool_vector , bool , bool)") -cfunc.bool_vector_size = cwrapper.prototype("bool bool_vector_size( bool_vector )") -cfunc.bool_vector_append = cwrapper.prototype("void bool_vector_append( bool_vector , bool )") -cfunc.bool_vector_idel_block = cwrapper.prototype("void bool_vector_idel_block( bool_vector , bool , bool )") -cfunc.bool_vector_fprintf = cwrapper.prototype("void bool_vector_fprintf( bool_vector , FILE , char* , char*)") -cfunc.bool_vector_sort = cwrapper.prototype("void bool_vector_sort( bool_vector )") -cfunc.bool_vector_rsort = cwrapper.prototype("void bool_vector_rsort( bool_vector )") -cfunc.bool_vector_reset = cwrapper.prototype("void bool_vector_reset( bool_vector )") -cfunc.bool_vector_set_read_only = cwrapper.prototype("void bool_vector_set_read_only( bool_vector , bool )") -cfunc.bool_vector_get_read_only = cwrapper.prototype("bool bool_vector_get_read_only( bool_vector )") -cfunc.bool_vector_get_max = cwrapper.prototype("bool bool_vector_get_max( bool_vector )") -cfunc.bool_vector_get_min = cwrapper.prototype("bool bool_vector_get_min( bool_vector )") -cfunc.bool_vector_get_max_index = cwrapper.prototype("bool bool_vector_get_max_index( bool_vector , bool)") -cfunc.bool_vector_get_min_index = cwrapper.prototype("bool bool_vector_get_min_index( bool_vector , bool)") -cfunc.bool_vector_shift = cwrapper.prototype("void bool_vector_shift( bool_vector , bool )") -cfunc.bool_vector_scale = cwrapper.prototype("void bool_vector_scale( bool_vector , bool )") -cfunc.bool_vector_div = cwrapper.prototype("void bool_vector_div( bool_vector , bool )") -cfunc.bool_vector_inplace_add = cwrapper.prototype("void bool_vector_inplace_add( bool_vector , bool_vector )") -cfunc.bool_vector_inplace_mul = cwrapper.prototype("void bool_vector_inplace_mul( bool_vector , bool_vector )") -cfunc.bool_vector_assign = cwrapper.prototype("void bool_vector_set_all( bool_vector , bool)") -cfunc.bool_vector_memcpy = cwrapper.prototype("void bool_vector_memcpy(bool_vector , bool_vector )") -cfunc.bool_vector_set_default = cwrapper.prototype("void bool_vector_set_default( bool_vector , bool)") -cfunc.bool_vector_get_default = cwrapper.prototype("bool bool_vector_get_default( bool_vector )") -cfunc.bool_vector_alloc_data_copy = cwrapper.prototype("bool* bool_vector_alloc_data_copy( bool_vector )") -cfunc.bool_vector_data_ptr = cwrapper.prototype("bool* bool_vector_get_ptr( bool_vector )") -cfunc.bool_vector_element_size = cwrapper.prototype("int bool_vector_element_size( bool_vector )") +BoolVector.cNamespace().alloc = cwrapper.prototype("c_void_p bool_vector_alloc( int , bool )") +BoolVector.cNamespace().alloc_copy = cwrapper.prototype("bool_vector_obj bool_vector_alloc_copy( bool_vector )") +BoolVector.cNamespace().strided_copy = cwrapper.prototype("bool_vector_obj bool_vector_alloc_strided_copy( bool_vector , bool , bool , bool)") +BoolVector.cNamespace().free = cwrapper.prototype("void bool_vector_free( bool_vector )") +BoolVector.cNamespace().iget = cwrapper.prototype("bool bool_vector_iget( bool_vector , bool )") +BoolVector.cNamespace().safe_iget = cwrapper.prototype("bool bool_vector_safe_iget( bool_vector , bool )") +BoolVector.cNamespace().iset = cwrapper.prototype("bool bool_vector_iset( bool_vector , bool , bool)") +BoolVector.cNamespace().size = cwrapper.prototype("bool bool_vector_size( bool_vector )") +BoolVector.cNamespace().append = cwrapper.prototype("void bool_vector_append( bool_vector , bool )") +BoolVector.cNamespace().idel_block = cwrapper.prototype("void bool_vector_idel_block( bool_vector , bool , bool )") +BoolVector.cNamespace().fprintf = cwrapper.prototype("void bool_vector_fprintf( bool_vector , FILE , char* , char*)") +BoolVector.cNamespace().sort = cwrapper.prototype("void bool_vector_sort( bool_vector )") +BoolVector.cNamespace().rsort = cwrapper.prototype("void bool_vector_rsort( bool_vector )") +BoolVector.cNamespace().reset = cwrapper.prototype("void bool_vector_reset( bool_vector )") +BoolVector.cNamespace().set_read_only = cwrapper.prototype("void bool_vector_set_read_only( bool_vector , bool )") +BoolVector.cNamespace().get_read_only = cwrapper.prototype("bool bool_vector_get_read_only( bool_vector )") +BoolVector.cNamespace().get_max = cwrapper.prototype("bool bool_vector_get_max( bool_vector )") +BoolVector.cNamespace().get_min = cwrapper.prototype("bool bool_vector_get_min( bool_vector )") +BoolVector.cNamespace().get_max_index = cwrapper.prototype("bool bool_vector_get_max_index( bool_vector , bool)") +BoolVector.cNamespace().get_min_index = cwrapper.prototype("bool bool_vector_get_min_index( bool_vector , bool)") +BoolVector.cNamespace().shift = cwrapper.prototype("void bool_vector_shift( bool_vector , bool )") +BoolVector.cNamespace().scale = cwrapper.prototype("void bool_vector_scale( bool_vector , bool )") +BoolVector.cNamespace().div = cwrapper.prototype("void bool_vector_div( bool_vector , bool )") +BoolVector.cNamespace().inplace_add = cwrapper.prototype("void bool_vector_inplace_add( bool_vector , bool_vector )") +BoolVector.cNamespace().inplace_mul = cwrapper.prototype("void bool_vector_inplace_mul( bool_vector , bool_vector )") +BoolVector.cNamespace().assign = cwrapper.prototype("void bool_vector_set_all( bool_vector , bool)") +BoolVector.cNamespace().memcpy = cwrapper.prototype("void bool_vector_memcpy(bool_vector , bool_vector )") +BoolVector.cNamespace().set_default = cwrapper.prototype("void bool_vector_set_default( bool_vector , bool)") +BoolVector.cNamespace().get_default = cwrapper.prototype("bool bool_vector_get_default( bool_vector )") +BoolVector.cNamespace().alloc_data_copy = cwrapper.prototype("bool* bool_vector_alloc_data_copy( bool_vector )") +BoolVector.cNamespace().data_ptr = cwrapper.prototype("bool* bool_vector_get_ptr( bool_vector )") +BoolVector.cNamespace().element_size = cwrapper.prototype("int bool_vector_element_size( bool_vector )") + +BoolVector.cNamespace().create_active_mask = cwrapper.prototype("bool_vector_obj string_util_alloc_active_mask( char* )") -cfunc.time_t_vector_alloc = cwrapper.prototype("c_void_p time_t_vector_alloc(int, time_t )") -cfunc.time_t_vector_alloc_copy = cwrapper.prototype("c_void_p time_t_vector_alloc_copy(time_t_vector )") -cfunc.time_t_vector_strided_copy = cwrapper.prototype("c_void_p time_t_vector_alloc_strided_copy(time_t_vector , time_t , time_t , time_t)") -# cfunc.time_t_vector_free = cwrapper.prototype("void time_t_vector_free( time_t_vector )") -cfunc.time_t_vector_iget = cwrapper.prototype("time_t time_t_vector_iget( time_t_vector , int )") -cfunc.time_t_vector_safe_iget = cwrapper.prototype("time_t time_t_vector_safe_iget( time_t_vector , int )") -cfunc.time_t_vector_iset = cwrapper.prototype("time_t time_t_vector_iset( time_t_vector , int , time_t)") -cfunc.time_t_vector_size = cwrapper.prototype("int time_t_vector_size( time_t_vector )") -cfunc.time_t_vector_append = cwrapper.prototype("void time_t_vector_append( time_t_vector , time_t )") -cfunc.time_t_vector_idel_block = cwrapper.prototype("void time_t_vector_idel_block( time_t_vector , int , int )") -cfunc.time_t_vector_fprintf = cwrapper.prototype("void time_t_vector_fprintf( time_t_vector , FILE , char* , char*)") -cfunc.time_t_vector_sort = cwrapper.prototype("void time_t_vector_sort( time_t_vector )") -cfunc.time_t_vector_rsort = cwrapper.prototype("void time_t_vector_rsort( time_t_vector )") -cfunc.time_t_vector_reset = cwrapper.prototype("void time_t_vector_reset( time_t_vector )") -cfunc.time_t_vector_set_read_only = cwrapper.prototype("void time_t_vector_set_read_only( time_t_vector , bool )") -cfunc.time_t_vector_get_read_only = cwrapper.prototype("bool time_t_vector_get_read_only( time_t_vector )") -cfunc.time_t_vector_get_max = cwrapper.prototype("time_t time_t_vector_get_max( time_t_vector )") -cfunc.time_t_vector_get_min = cwrapper.prototype("time_t time_t_vector_get_min( time_t_vector )") -cfunc.time_t_vector_get_max_index = cwrapper.prototype("int time_t_vector_get_max_index( time_t_vector , bool)") -cfunc.time_t_vector_get_min_index = cwrapper.prototype("int time_t_vector_get_min_index( time_t_vector , bool)") -cfunc.time_t_vector_shift = cwrapper.prototype("void time_t_vector_shift( time_t_vector , time_t )") -cfunc.time_t_vector_scale = cwrapper.prototype("void time_t_vector_scale( time_t_vector , time_t )") -cfunc.time_t_vector_div = cwrapper.prototype("void time_t_vector_div( time_t_vector , time_t )") -cfunc.time_t_vector_inplace_add = cwrapper.prototype("void time_t_vector_inplace_add( time_t_vector , time_t_vector )") -cfunc.time_t_vector_inplace_mul = cwrapper.prototype("void time_t_vector_inplace_mul( time_t_vector , time_t_vector )") -cfunc.time_t_vector_assign = cwrapper.prototype("void time_t_vector_set_all( time_t_vector , time_t)") -cfunc.time_t_vector_memcpy = cwrapper.prototype("void time_t_vector_memcpy(time_t_vector , time_t_vector )") -cfunc.time_t_vector_set_default = cwrapper.prototype("void time_t_vector_set_default( time_t_vector , time_t)") -cfunc.time_t_vector_get_default = cwrapper.prototype("time_t time_t_vector_get_default( time_t_vector )") -cfunc.time_t_vector_alloc_data_copy = cwrapper.prototype("time_t* time_t_vector_alloc_data_copy( time_t_vector )") -cfunc.time_t_vector_data_ptr = cwrapper.prototype("time_t* time_t_vector_get_ptr( time_t_vector )") -cfunc.time_t_vector_element_size = cwrapper.prototype("int time_t_vector_element_size( time_t_vector )") +TimeVector.cNamespace().alloc = cwrapper.prototype("c_void_p time_t_vector_alloc(int, time_t )") +TimeVector.cNamespace().alloc_copy = cwrapper.prototype("time_t_vector_obj time_t_vector_alloc_copy(time_t_vector )") +TimeVector.cNamespace().strided_copy = cwrapper.prototype("time_t_vector_obj time_t_vector_alloc_strided_copy(time_t_vector , time_t , time_t , time_t)") +TimeVector.cNamespace().free = cwrapper.prototype("void time_t_vector_free( time_t_vector )") +TimeVector.cNamespace().iget = cwrapper.prototype("time_t time_t_vector_iget( time_t_vector , int )") +TimeVector.cNamespace().safe_iget = cwrapper.prototype("time_t time_t_vector_safe_iget( time_t_vector , int )") +TimeVector.cNamespace().iset = cwrapper.prototype("time_t time_t_vector_iset( time_t_vector , int , time_t)") +TimeVector.cNamespace().size = cwrapper.prototype("int time_t_vector_size( time_t_vector )") +TimeVector.cNamespace().append = cwrapper.prototype("void time_t_vector_append( time_t_vector , time_t )") +TimeVector.cNamespace().idel_block = cwrapper.prototype("void time_t_vector_idel_block( time_t_vector , int , int )") +TimeVector.cNamespace().fprintf = cwrapper.prototype("void time_t_vector_fprintf( time_t_vector , FILE , char* , char*)") +TimeVector.cNamespace().sort = cwrapper.prototype("void time_t_vector_sort( time_t_vector )") +TimeVector.cNamespace().rsort = cwrapper.prototype("void time_t_vector_rsort( time_t_vector )") +TimeVector.cNamespace().reset = cwrapper.prototype("void time_t_vector_reset( time_t_vector )") +TimeVector.cNamespace().set_read_only = cwrapper.prototype("void time_t_vector_set_read_only( time_t_vector , bool )") +TimeVector.cNamespace().get_read_only = cwrapper.prototype("bool time_t_vector_get_read_only( time_t_vector )") +TimeVector.cNamespace().get_max = cwrapper.prototype("time_t time_t_vector_get_max( time_t_vector )") +TimeVector.cNamespace().get_min = cwrapper.prototype("time_t time_t_vector_get_min( time_t_vector )") +TimeVector.cNamespace().get_max_index = cwrapper.prototype("int time_t_vector_get_max_index( time_t_vector , bool)") +TimeVector.cNamespace().get_min_index = cwrapper.prototype("int time_t_vector_get_min_index( time_t_vector , bool)") +TimeVector.cNamespace().shift = cwrapper.prototype("void time_t_vector_shift( time_t_vector , time_t )") +TimeVector.cNamespace().scale = cwrapper.prototype("void time_t_vector_scale( time_t_vector , time_t )") +TimeVector.cNamespace().div = cwrapper.prototype("void time_t_vector_div( time_t_vector , time_t )") +TimeVector.cNamespace().inplace_add = cwrapper.prototype("void time_t_vector_inplace_add( time_t_vector , time_t_vector )") +TimeVector.cNamespace().inplace_mul = cwrapper.prototype("void time_t_vector_inplace_mul( time_t_vector , time_t_vector )") +TimeVector.cNamespace().assign = cwrapper.prototype("void time_t_vector_set_all( time_t_vector , time_t)") +TimeVector.cNamespace().memcpy = cwrapper.prototype("void time_t_vector_memcpy(time_t_vector , time_t_vector )") +TimeVector.cNamespace().set_default = cwrapper.prototype("void time_t_vector_set_default( time_t_vector , time_t)") +TimeVector.cNamespace().get_default = cwrapper.prototype("time_t time_t_vector_get_default( time_t_vector )") +TimeVector.cNamespace().alloc_data_copy = cwrapper.prototype("time_t* time_t_vector_alloc_data_copy( time_t_vector )") +TimeVector.cNamespace().data_ptr = cwrapper.prototype("time_t* time_t_vector_get_ptr( time_t_vector )") +TimeVector.cNamespace().element_size = cwrapper.prototype("int time_t_vector_element_size( time_t_vector )") #----------------------------------------------------------------- -cfunc.create_active_list = cwrapper.prototype("c_void_p string_util_alloc_active_list( char* )") -cfunc.create_active_mask = cwrapper.prototype("c_void_p string_util_alloc_active_mask( char* )") + + diff --git a/ThirdParty/Ert/devel/python/python/ert_gui/pages/application.py b/ThirdParty/Ert/devel/python/python/ert_gui/pages/application.py index 0b17f8fbd9..605c29e2b1 100644 --- a/ThirdParty/Ert/devel/python/python/ert_gui/pages/application.py +++ b/ThirdParty/Ert/devel/python/python/ert_gui/pages/application.py @@ -69,7 +69,7 @@ class Application(QtGui.QMainWindow): self.save_function() def _createDock(self): - dock = QDockWidget("Workflow") + dock = QDockWidget("") dock.setObjectName("ERTGUI Workflow") dock.setWidget(self.contentsWidget) dock.setFeatures(QDockWidget.DockWidgetClosable) diff --git a/ThirdParty/Ert/devel/python/test/CMakeLists.txt b/ThirdParty/Ert/devel/python/test/CMakeLists.txt index 8c9e3f1146..f36d8fd6ef 100644 --- a/ThirdParty/Ert/devel/python/test/CMakeLists.txt +++ b/ThirdParty/Ert/devel/python/test/CMakeLists.txt @@ -10,6 +10,9 @@ set(TEST_SOURCES ert_tests/config/__init__.py ert_tests/config/test_config.py + ert_tests/cwrap/__init__.py + ert_tests/cwrap/test_cwrap.py + ert_tests/ecl/__init__.py ert_tests/ecl/test_ecl_default.py ert_tests/ecl/test_ecl_file.py @@ -25,19 +28,24 @@ set(TEST_SOURCES ert_tests/ecl/test_rft_cell.py ert_tests/ecl/test_sum.py + ert_tests/enkf/__init__.py + ert_tests/enkf/test_enkf.py + ert_tests/enkf/test_enkf_library.py + ert_tests/sched/__init__.py ert_tests/sched/test_sched.py ert_tests/util/__init__.py ert_tests/util/test_ctime.py + ert_tests/util/test_hash.py ert_tests/util/test_lookup_table.py ert_tests/util/test_matrix.py ert_tests/util/test_stat.py ert_tests/util/test_string_list.py ert_tests/util/test_vectors.py + ecl_isosurf.py - enkf_test.py ens_config_test.py grav_test.py grid_test0.py @@ -80,9 +88,15 @@ add_test( NAME python.ert.util.ctime WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.util.test_ctime.CTimeTest) -add_test( NAME python.ert.util.latex + +add_test( NAME python.ert.util.hash WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} - COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.util.test_latex.LatexTest ) + COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.util.test_hash.HashTest) + + +#add_test( NAME python.ert.util.latex +# WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} +# COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.util.test_latex.LatexTest ) add_test( NAME python.ert.util.lookup_table WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} @@ -97,6 +111,15 @@ add_test( NAME python.ert.util.stat COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.util.test_stat.StatTest ) +#ENKF +add_test( NAME python.ert.enkf + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.enkf.test_enkf.EnKFTest) + +add_test( NAME python.ert.enkf_library + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.enkf.test_enkf_library.EnKFLibraryTest) + #ECL @@ -181,6 +204,18 @@ add_test( NAME python.ert.config WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.config.test_config.ConfigTest) +#CWRAP +add_test( NAME python.ert.cwrap + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.cwrap.test_cwrap.CWRapTest) + +add_test( NAME python.ert.cwrap.basecclass + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.cwrap.test_basecclass.BaseCClassTest) + +add_test( NAME python.ert.cwrap.basecenum + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + COMMAND ctest_run.py ${PROJECT_BINARY_DIR}/${PYTHON_INSTALL_PREFIX} ert_tests.cwrap.test_basecenum.BaseCEnumTest) diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/config/test_config.py b/ThirdParty/Ert/devel/python/test/ert_tests/config/test_config.py index ddba94a7aa..a6d5c07424 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/config/test_config.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/config/test_config.py @@ -15,7 +15,6 @@ # See the GNU General Public License at # for more details. -from unittest2 import TestSuite, TextTestRunner from ert.config import ContentTypeEnum, UnrecognizedEnum, SchemaItem, ContentItem, ContentNode, ConfigParser from ert_tests import ExtendedTestCase @@ -30,6 +29,9 @@ class ConfigTest(ExtendedTestCase): self.assertTrue(ContentTypeEnum.CONFIG_INVALID) self.assertTrue(UnrecognizedEnum.CONFIG_UNRECOGNIZED_ERROR) + self.assertEqual(ContentTypeEnum.CONFIG_STRING, 1) + self.assertEqual(ContentTypeEnum.CONFIG_INVALID, 512) + def test_parse(self): conf = ConfigParser() @@ -72,16 +74,4 @@ class ConfigTest(ExtendedTestCase): self.assertEqual(schema_item.iget_type(0), ContentTypeEnum.CONFIG_INT) schema_item.set_argc_minmax(3, 6) - -def fast_suite(): - suite = TestSuite() - suite.addTest(ConfigTest('test_enums')) - suite.addTest(ConfigTest('test_schema')) - suite.addTest(ConfigTest('test_parse')) - return suite - - -if __name__ == "__main__": - TextTestRunner().run(fast_suite()) - - + del schema_item diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/__init__.py b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecclass.py b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecclass.py new file mode 100644 index 0000000000..6e71ee8129 --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecclass.py @@ -0,0 +1,12 @@ +from ert.cwrap import BaseCClass +from ert_tests import ExtendedTestCase + + +class BaseCClassTest(ExtendedTestCase): + + def test_none_assertion(self): + self.assertFalse(None > 0) + + def test_creation(self): + with self.assertRaises(ValueError): + obj = BaseCClass(0) \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecenum.py b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecenum.py new file mode 100644 index 0000000000..256b7e75a3 --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_basecenum.py @@ -0,0 +1,83 @@ +from ert.config import CONFIG_LIB +from ert.cwrap import BaseCEnum +from ert_tests import ExtendedTestCase + + + +class BaseCEnumTest(ExtendedTestCase): + def test_base_c_enum(self): + class enum(BaseCEnum): + pass + + enum.addEnum("ONE", 1) + enum.addEnum("TWO", 2) + enum.addEnum("THREE", 3) + enum.addEnum("FOUR", 4) + + class enum2(BaseCEnum): + pass + + enum2.addEnum("ONE", 1) + enum2.addEnum("TWO", 4) + + self.assertEqual(enum.ONE, 1) + self.assertEqual(enum.TWO, 2) + self.assertEqual(enum.FOUR, 4) + + self.assertListEqual(enum.enums(), [enum.ONE, enum.TWO, enum.THREE, enum.FOUR]) + + self.assertEqual(enum(4), enum.FOUR) + + self.assertNotEqual(enum2(4), enum.FOUR) + self.assertEqual(enum2(4), enum2.TWO) + + self.assertEqual(str(enum.ONE), "ONE") + + + self.assertEqual(enum.ONE + enum.TWO, enum.THREE) + self.assertEqual(enum.ONE + enum.FOUR, 5) + + with self.assertRaises(ValueError): + e = enum(5) + + + self.assertEqual(enum.THREE & enum.ONE, enum.ONE) + self.assertEqual(enum.ONE | enum.TWO, enum.THREE) + self.assertEqual(enum.THREE ^ enum.TWO, enum.ONE) + + + with self.assertRaises(AssertionError): + e = enum.ONE + enum2.ONE + + with self.assertRaises(AssertionError): + e = enum.ONE & enum2.ONE + + with self.assertRaises(AssertionError): + e = enum.ONE | enum2.ONE + + with self.assertRaises(AssertionError): + e = enum.ONE ^ enum2.ONE + + + def test_enum_populate_from_c(self): + class ContentTypeEnum(BaseCEnum): + pass + + ContentTypeEnum.populateEnum(CONFIG_LIB, "config_schema_item_type_enum_iget") + + # CONFIG_STRING = 1, + # CONFIG_INT = 2, + # CONFIG_FLOAT = 4, + # CONFIG_PATH = 8, + # CONFIG_EXISTING_PATH = 16, + # CONFIG_BOOL = 32, + # CONFIG_CONFIG = 64, + # CONFIG_BYTESIZE = 128, + # CONFIG_EXECUTABLE = 256 , + # CONFIG_INVALID = 512 + + self.assertEqual(ContentTypeEnum.CONFIG_STRING, 1) + self.assertEqual(ContentTypeEnum.CONFIG_EXISTING_PATH, 16) + self.assertEqual(ContentTypeEnum.CONFIG_BYTESIZE, 128) + self.assertEqual(ContentTypeEnum.CONFIG_INVALID, 512) + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_cwrap.py b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_cwrap.py new file mode 100644 index 0000000000..3557967beb --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/cwrap/test_cwrap.py @@ -0,0 +1,66 @@ +import ctypes +from ert.cwrap import CWrapper, CWrapperNameSpace, CClass, BaseCClass +from ert.util import UTIL_LIB +from ert_tests import ExtendedTestCase + + + + +class StringListTest(BaseCClass): + def __init__(self): + c_pointer = self.cNamespace().stringlist_alloc() + super(StringListTest, self).__init__(c_pointer) + + def free(self): + StringListTest.cNamespace().free(self) + + +class CWRapTest(ExtendedTestCase): + def test_return_type(self): + stringlist_alloc = cwrapper.prototype("c_void_p stringlist_alloc_new( )") + string_list1 = StringListTest() + + stringlist_alloc = cwrapper.prototype("StringListObj stringlist_alloc_new( )") + string_list2 = stringlist_alloc() + + stringlist_alloc = cwrapper.prototype("StringListRef stringlist_alloc_new( )") + string_list3 = stringlist_alloc() + + self.assertIsInstance(string_list1, StringListTest) + self.assertIsInstance(string_list2, StringListTest) + self.assertIsInstance(string_list3, StringListTest) + + self.assertFalse(string_list1.isReference()) + self.assertFalse(string_list2.isReference()) + self.assertTrue(string_list3.isReference()) + + self.assertNotEqual(BaseCClass.from_param(string_list1), BaseCClass.from_param(string_list2)) + self.assertNotEqual(BaseCClass.from_param(string_list2), BaseCClass.from_param(string_list3)) + self.assertNotEqual(BaseCClass.from_param(string_list1), BaseCClass.from_param(string_list3)) + + + def test_class_variables(self): + BaseCClass.cNamespace().hello = "BooYa!" + StringListTest.cNamespace()["pow"] = "Badonkadonk!" + + with self.assertRaises(AssertionError): + StringListTest.cNamespace().pow = "Badonkadonka!" + + with self.assertRaises(LookupError): + self.assertFalse(BaseCClass.cNamespace()["pow"]) + + with self.assertRaises(AttributeError): + self.assertFalse(StringListTest.cNamespace().hello) + + self.assertEqual(StringListTest.cNamespace().pow, StringListTest.cNamespace()["pow"]) + + +CWrapper.registerType("stringlist", StringListTest) +CWrapper.registerType("StringListObj", StringListTest.createPythonObject) +CWrapper.registerType("StringListRef", StringListTest.createCReference) + +cwrapper = CWrapper(UTIL_LIB) + +StringListTest.cNamespace().stringlist_alloc = cwrapper.prototype("c_void_p stringlist_alloc_new( )") +StringListTest.cNamespace().free = cwrapper.prototype("void stringlist_free(stringlist)") + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_file.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_file.py index d850841f66..c57393ea11 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_file.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_file.py @@ -18,7 +18,7 @@ from unittest2 import skipIf from ert.ecl import EclFile, FortIO from ert.ecl.ecl_util import EclFileFlagEnum -from ert.util import TestAreaContext +from ert.util.test_area import TestAreaContext from ert_tests import ExtendedTestCase diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_submit.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_submit.py index 8dade805b0..c88efd0cc0 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_submit.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_ecl_submit.py @@ -17,12 +17,12 @@ # import os import getpass -from unittest2 import TestSuite, TextTestRunner, skip, skipIf +from unittest2 import skipIf import time import shutil from ert.ecl import EclQueue, EclSum from ert.job_queue import QueueDriverEnum, RSHDriver -from ert.util import TestAreaContext +from ert.util.test_area import TestAreaContext from ert_tests import ExtendedTestCase @@ -65,12 +65,12 @@ class EclSubmitTest(ExtendedTestCase): class LSFSubmitTest(EclSubmitTest): + @skipIf(ExtendedTestCase.slowTestShouldNotRun(), "Slow LSF job submit skipped!") def test_start_parameters(self): self.assertIsNotNone(self.nfs_work_path, "NFS work path missing!") self.assertIsNone(self.rsh_servers) - #@skip("LSF not defined!") @skipIf(ExtendedTestCase.slowTestShouldNotRun(), "Slow LSF job submit skipped!") def test_LSF_submit(self): root = os.path.join(self.nfs_work_path, getpass.getuser(), "ert-test/python/ecl_submit/LSF") @@ -85,9 +85,9 @@ class LSFSubmitTest(EclSubmitTest): for iens in (range(num_submit)): run_path = self.make_run_path(iens, LSF=True) path_list.append(run_path) - job = queue.submit("%s/%s.DATA" % (run_path, LSF_base)) + job = queue.submitDataFile("%s/%s.DATA" % (run_path, LSF_base)) - while queue.running: + while queue.isRunning(): time.sleep(1) for path in path_list: @@ -97,8 +97,11 @@ class LSFSubmitTest(EclSubmitTest): class RSHSubmitTest(EclSubmitTest): + @skipIf(ExtendedTestCase.slowTestShouldNotRun(), "Slow RSH job submit skipped!") + def test_start_parameters(self): + self.assertIsNotNone(self.nfs_work_path, "NFS work path missing!") + self.assertIsNotNone(self.rsh_servers, "RSH servers missing!") - #@skip("RSH not defined!") @skipIf(ExtendedTestCase.slowTestShouldNotRun(), "Slow RSH job submit skipped!") def test_RSH_submit(self): root = os.path.join(self.nfs_work_path, getpass.getuser(), "ert-test/python/ecl_submit/RSH") @@ -122,14 +125,14 @@ class RSHSubmitTest(EclSubmitTest): for iens in (range(num_submit)): run_path = self.make_run_path(iens) path_list.append(run_path) - job = queue.submit("%s/%s.DATA" % (run_path, base)) + job = queue.submitDataFile("%s/%s.DATA" % (run_path, base)) - while queue.running: + while queue.isRunning(): time.sleep(1) for path in path_list: sum = EclSum("%s/%s" % (path, base)) - self.assertTrue(isinstance(sum, EclSum)) + self.assertIsInstance(sum, EclSum) self.assertEqual(2, sum.last_report) class LocalSubmitTest(EclSubmitTest): @@ -146,15 +149,15 @@ class LocalSubmitTest(EclSubmitTest): for iens in range(num_submit): run_path = self.make_run_path(iens) path_list.append(run_path) - job = queue.submit("%s/%s.DATA" % (run_path, base)) + job = queue.submitDataFile("%s/%s.DATA" % (run_path, base)) queue.submit_complete() - while queue.running: + while queue.isRunning(): time.sleep(1) for path in path_list: sum = EclSum("%s/%s" % (path, base)) - self.assertTrue(isinstance(sum, EclSum)) + self.assertIsInstance(sum, EclSum) self.assertEqual(2, sum.last_report) shutil.rmtree(path) diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_fortio.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_fortio.py index d071f4cee6..bb1499f2f5 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_fortio.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_fortio.py @@ -17,7 +17,7 @@ import os from ert.ecl import FortIO, EclTypeEnum, EclKW from ert_tests import ExtendedTestCase -from ert.util import TestAreaContext +from ert.util.test_area import TestAreaContext @@ -25,7 +25,6 @@ from ert.util import TestAreaContext class FortIOTest(ExtendedTestCase): def setUp(self): self.unrst_file = self.createTestPath("Statoil/ECLIPSE/Gurbat/ECLIPSE.UNRST") - self.file_list = [] def test_open_read(self): diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_grid.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_grid.py index fe2b804f52..33a4cb5230 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_grid.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_grid.py @@ -17,7 +17,8 @@ import time from unittest2 import skipIf from ert.ecl import EclTypeEnum, EclKW, EclGrid -from ert.util import DoubleVector, TestAreaContext +from ert.util import DoubleVector +from ert.util.test_area import TestAreaContext from ert_tests import ExtendedTestCase diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_kw.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_kw.py index c364b0da3e..5419244360 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_kw.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_kw.py @@ -16,7 +16,7 @@ # for more details. import os from ert.ecl import EclKW, EclTypeEnum, EclFile -from ert.util import TestAreaContext +from ert.util.test_area import TestAreaContext from ert_tests import ExtendedTestCase diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_region.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_region.py index 9579bfbc66..53fd58a9bf 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_region.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_region.py @@ -88,7 +88,11 @@ class RegionTest(ExtendedTestCase): reg = EclRegion(self.grid, False) reg.select_islice(0, 5) OK = True - for gi in reg.global_list: + + global_list = reg.global_list + self.assertEqual(global_list.parent(), reg) + + for gi in global_list: (i, j, k) = self.grid.get_ijk(global_index=gi) if i > 5: OK = False @@ -126,3 +130,4 @@ class RegionTest(ExtendedTestCase): self.assertTrue(OK) self.assertTrue(2 * 3 * 6 == len(reg.global_list)) + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_sum.py b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_sum.py index 9927493b7c..d5f1ad97c1 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_sum.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/ecl/test_sum.py @@ -20,7 +20,8 @@ import datetime from unittest2 import skip, skipUnless, skipIf from ert.ecl import EclSum -from ert.util import StringList, TestAreaContext +from ert.util import StringList, TimeVector, DoubleVector +from ert.util.test_area import TestAreaContext from ert_tests import ExtendedTestCase @@ -261,3 +262,10 @@ class SumTest(ExtendedTestCase): nr = int(tmp[2]) self.assertTrue(nr >= 0) + def test_return_types(self): + self.assertIsInstance(self.ecl_sum.alloc_time_vector(True), TimeVector) + key_index = self.ecl_sum.get_general_var_index("FOPT") + self.assertIsInstance(self.ecl_sum.alloc_data_vector(key_index, True), DoubleVector) + + + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/enkf/__init__.py b/ThirdParty/Ert/devel/python/test/ert_tests/enkf/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf.py b/ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf.py new file mode 100644 index 0000000000..9b7c1aba7b --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python +# Copyright (C) 2012 Statoil ASA, Norway. +# +# The file 'test_enkf.py' is part of ERT - Ensemble based Reservoir Tool. +# +# ERT is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# ERT is distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. +# +# See the GNU General Public License at +# for more details. + +import os +from ert.enkf import EnkfStateEnum, EnsConfig, AnalysisConfig, ModelConfig, SiteConfig, EclConfig, PlotConfig, EnkfObs, ErtTemplates, EnkfFs, EnKFState +from ert.enkf.local_config import LocalConfig +from ert.enkf.enkf_main import EnKFMain +from ert.util.test_area import TestAreaContext +from ert_tests import ExtendedTestCase + + + +class EnKFTest(ExtendedTestCase): + def setUp(self): + self.case_directory = self.createTestPath("local/simple_config/") + self.site_config_file = os.getenv("ERT_SITE_CONFIG") + + + def test_bootstrap( self ): + with TestAreaContext("enkf_test", store_area=True) as work_area: + work_area.copy_directory(self.case_directory) + main = EnKFMain("simple_config/minimum_config", self.site_config_file) + self.assertTrue(main, "Load failed") + del main + + def test_enum(self): + self.assertEqual(EnkfStateEnum.FORECAST, 2) + self.assertEqual(EnkfStateEnum.ANALYZED, 4) + + def test_config( self ): + with TestAreaContext("enkf_test") as work_area: + work_area.copy_directory(self.case_directory) + + main = EnKFMain("simple_config/minimum_config", self.site_config_file) + + self.assertIsInstance(main.ensemble_config(), EnsConfig) + self.assertIsInstance(main.analysis_config(), AnalysisConfig) + self.assertIsInstance(main.model_config(), ModelConfig) + #self.assertIsInstance(main.local_config(), LocalConfig) #warn: Should this be None? + self.assertIsInstance(main.site_config(), SiteConfig) + self.assertIsInstance(main.ecl_config(), EclConfig) + self.assertIsInstance(main.plot_config(), PlotConfig) + + # self.main.load_obs(obs_config_file) + self.assertIsInstance(main.get_obs(), EnkfObs) + self.assertIsInstance(main.get_templates(), ErtTemplates) + self.assertIsInstance(main.get_fs(), EnkfFs) + # self.assertIsInstance(main.iget_member_config(0), MemberConfig) + self.assertIsInstance(main.iget_state(0), EnKFState) + + del main diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf_library.py b/ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf_library.py new file mode 100644 index 0000000000..1ce24211f1 --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/enkf/test_enkf_library.py @@ -0,0 +1,53 @@ +import os +from ert.ecl import EclSum +from ert.enkf import BlockObs, AnalysisConfig, EclConfig, GenKwConfig, EnkfConfigNode, SiteConfig, EnkfStateEnum +from ert.enkf import GenDataConfig, FieldConfig, EnkfFs, EnkfObs, EnKFState, EnsConfig +from ert.enkf import ErtTemplate, ErtTemplates, LocalConfig, ModelConfig, PlotConfig +from ert.enkf.enkf_main import EnKFMain + +from ert.enkf.util import ObsVector, TimeMap +from ert.util.test_area import TestAreaContext +from ert_tests import ExtendedTestCase + + +class EnKFLibraryTest(ExtendedTestCase): + def setUp(self): + self.case_directory = self.createTestPath("local/simple_config/") + self.site_config = os.getenv("ERT_SITE_CONFIG") + + + def test_failed_class_creation(self): + classes = [AnalysisConfig, BlockObs, FieldConfig, GenKwConfig, GenDataConfig, + EnkfConfigNode, EnkfFs, EnkfObs, TimeMap, ObsVector, EnKFState, EnsConfig, + ErtTemplate, ErtTemplates, LocalConfig, ModelConfig, PlotConfig, SiteConfig] + + for cls in classes: + with self.assertRaises(NotImplementedError): + temp = cls() + + + def test_enums(self): + print(EnkfStateEnum.enum_names) + + def test_ecl_config_creation(self): + with self.assertRaises(NotImplementedError): + ecl_config = EclConfig() + + with TestAreaContext("enkf_library_test") as work_area: + work_area.copy_directory(self.case_directory) + + main = EnKFMain("simple_config/minimum_config", self.site_config) + + self.assertIsInstance(main.analysis_config(), AnalysisConfig) + self.assertIsInstance(main.ecl_config(), EclConfig) + + with self.assertRaises(AttributeError): + self.assertIsInstance(main.ecl_config().get_refcase(), EclSum) + + time_map = main.get_fs().get_time_map() + self.assertIsInstance(time_map, TimeMap) + + del main + + + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_gui_import.py b/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_gui_import.py index 899816a8d4..16e5003de9 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_gui_import.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_gui_import.py @@ -21,89 +21,90 @@ from ert_tests import ExtendedTestCase class ErtGuiImportTest(ExtendedTestCase): - def test_ert_gui(self): - self.assertImportable("ert_gui") - self.assertImportable("ert_gui.gert_main") - self.assertImportable("ert_gui.newconfig") - - def test_ert_gui_widgets(self): - self.assertImportable("ert_gui.widgets") - self.assertImportable("ert_gui.widgets.activelabel") - self.assertImportable("ert_gui.widgets.checkbox") - self.assertImportable("ert_gui.widgets.cogwheel") - self.assertImportable("ert_gui.widgets.combochoice") - self.assertImportable("ert_gui.widgets.configpanel") - self.assertImportable("ert_gui.widgets.help") - self.assertImportable("ert_gui.widgets.helpedwidget") - self.assertImportable("ert_gui.widgets.pathchooser") - self.assertImportable("ert_gui.widgets.reloadbutton") - self.assertImportable("ert_gui.widgets.searchablelist") - self.assertImportable("ert_gui.widgets.spinnerwidgets") - self.assertImportable("ert_gui.widgets.stringbox") - self.assertImportable("ert_gui.widgets.tablewidgets") - self.assertImportable("ert_gui.widgets.util") - self.assertImportable("ert_gui.widgets.validateddialog") - - def test_ert_gui_pages(self): - self.assertImportable("ert_gui.pages") - self.assertImportable("ert_gui.pages.application") - - def test_ert_gui_pages_init(self): - self.assertImportable("ert_gui.pages.init") - self.assertImportable("ert_gui.pages.init.initandcopy") - self.assertImportable("ert_gui.pages.init.initpanel") - - def test_ert_gui_pages_run(self): - self.assertImportable("ert_gui.pages.run") - self.assertImportable("ert_gui.pages.run.legend") - self.assertImportable("ert_gui.pages.run.runpanel") - self.assertImportable("ert_gui.pages.run.simulation") - self.assertImportable("ert_gui.pages.run.simulationsdialog") - - def test_ert_gui_pages_plot(self): - self.assertImportable("ert_gui.pages.plot") - self.assertImportable("ert_gui.pages.plot.ensemblefetcher") - self.assertImportable("ert_gui.pages.plot.fetcher") - self.assertImportable("ert_gui.pages.plot.plotconfig") - self.assertImportable("ert_gui.pages.plot.plotdata") - self.assertImportable("ert_gui.pages.plot.plotfigure") - self.assertImportable("ert_gui.pages.plot.plotgenerator") - self.assertImportable("ert_gui.pages.plot.plotpanel") - self.assertImportable("ert_gui.pages.plot.plotrenderer") - self.assertImportable("ert_gui.pages.plot.plotsettings") - self.assertImportable("ert_gui.pages.plot.plotsettingsxml") - self.assertImportable("ert_gui.pages.plot.plotview") - self.assertImportable("ert_gui.pages.plot.rftfetcher") - self.assertImportable("ert_gui.pages.plot.zoomslider") - - def test_ert_gui_pages_config(self): - self.assertImportable("ert_gui.pages.config") - self.assertImportable("ert_gui.pages.config.analysis") - self.assertImportable("ert_gui.pages.config.configpages") - self.assertImportable("ert_gui.pages.config.eclipse") - self.assertImportable("ert_gui.pages.config.ensemble") - self.assertImportable("ert_gui.pages.config.observations") - self.assertImportable("ert_gui.pages.config.plot") - self.assertImportable("ert_gui.pages.config.queuesystem") - self.assertImportable("ert_gui.pages.config.simulation") - self.assertImportable("ert_gui.pages.config.systemenv") - - def test_ert_gui_pages_config_jobs(self): - self.assertImportable("ert_gui.pages.config.jobs") - self.assertImportable("ert_gui.pages.config.jobs.forwardmodelpanel") - self.assertImportable("ert_gui.pages.config.jobs.jobsdialog") - self.assertImportable("ert_gui.pages.config.jobs.jobspanel") - - def test_ert_gui_pages_config_parameters(self): - self.assertImportable("ert_gui.pages.config.parameters") - self.assertImportable("ert_gui.pages.config.parameters.datapanel") - self.assertImportable("ert_gui.pages.config.parameters.fieldpanel") - self.assertImportable("ert_gui.pages.config.parameters.keywordpanel") - self.assertImportable("ert_gui.pages.config.parameters.parameterdialog") - self.assertImportable("ert_gui.pages.config.parameters.parametermodels") - self.assertImportable("ert_gui.pages.config.parameters.parameterpanel") - - def test_ert_gui_pages_config_simulations(self): - self.assertImportable("ert_gui.pages.config.simulations") - self.assertImportable("ert_gui.pages.config.simulations.runpathpanel") - self.assertImportable("ert_gui.pages.config.simulations.runtemplatepanel") + pass + # def test_ert_gui(self): + # self.assertImportable("ert_gui") + # self.assertImportable("ert_gui.gert_main") + # self.assertImportable("ert_gui.newconfig") + # + # def test_ert_gui_widgets(self): + # self.assertImportable("ert_gui.widgets") + # self.assertImportable("ert_gui.widgets.activelabel") + # self.assertImportable("ert_gui.widgets.checkbox") + # self.assertImportable("ert_gui.widgets.cogwheel") + # self.assertImportable("ert_gui.widgets.combochoice") + # self.assertImportable("ert_gui.widgets.configpanel") + # self.assertImportable("ert_gui.widgets.help") + # self.assertImportable("ert_gui.widgets.helpedwidget") + # self.assertImportable("ert_gui.widgets.pathchooser") + # self.assertImportable("ert_gui.widgets.reloadbutton") + # self.assertImportable("ert_gui.widgets.searchablelist") + # self.assertImportable("ert_gui.widgets.spinnerwidgets") + # self.assertImportable("ert_gui.widgets.stringbox") + # self.assertImportable("ert_gui.widgets.tablewidgets") + # self.assertImportable("ert_gui.widgets.util") + # self.assertImportable("ert_gui.widgets.validateddialog") + # + # def test_ert_gui_pages(self): + # self.assertImportable("ert_gui.pages") + # self.assertImportable("ert_gui.pages.application") + # + # def test_ert_gui_pages_init(self): + # self.assertImportable("ert_gui.pages.init") + # self.assertImportable("ert_gui.pages.init.initandcopy") + # self.assertImportable("ert_gui.pages.init.initpanel") + # + # def test_ert_gui_pages_run(self): + # self.assertImportable("ert_gui.pages.run") + # self.assertImportable("ert_gui.pages.run.legend") + # self.assertImportable("ert_gui.pages.run.runpanel") + # self.assertImportable("ert_gui.pages.run.simulation") + # self.assertImportable("ert_gui.pages.run.simulationsdialog") + # + # def test_ert_gui_pages_plot(self): + # self.assertImportable("ert_gui.pages.plot") + # self.assertImportable("ert_gui.pages.plot.ensemblefetcher") + # self.assertImportable("ert_gui.pages.plot.fetcher") + # self.assertImportable("ert_gui.pages.plot.plotconfig") + # self.assertImportable("ert_gui.pages.plot.plotdata") + # self.assertImportable("ert_gui.pages.plot.plotfigure") + # self.assertImportable("ert_gui.pages.plot.plotgenerator") + # self.assertImportable("ert_gui.pages.plot.plotpanel") + # self.assertImportable("ert_gui.pages.plot.plotrenderer") + # self.assertImportable("ert_gui.pages.plot.plotsettings") + # self.assertImportable("ert_gui.pages.plot.plotsettingsxml") + # self.assertImportable("ert_gui.pages.plot.plotview") + # self.assertImportable("ert_gui.pages.plot.rftfetcher") + # self.assertImportable("ert_gui.pages.plot.zoomslider") + # + # def test_ert_gui_pages_config(self): + # self.assertImportable("ert_gui.pages.config") + # self.assertImportable("ert_gui.pages.config.analysis") + # # self.assertImportable("ert_gui.pages.config.configpages") + # self.assertImportable("ert_gui.pages.config.eclipse") + # # self.assertImportable("ert_gui.pages.config.ensemble") + # # self.assertImportable("ert_gui.pages.config.observations") + # self.assertImportable("ert_gui.pages.config.plot") + # self.assertImportable("ert_gui.pages.config.queuesystem") + # self.assertImportable("ert_gui.pages.config.simulation") + # self.assertImportable("ert_gui.pages.config.systemenv") + # + # def test_ert_gui_pages_config_jobs(self): + # self.assertImportable("ert_gui.pages.config.jobs") + # self.assertImportable("ert_gui.pages.config.jobs.forwardmodelpanel") + # self.assertImportable("ert_gui.pages.config.jobs.jobsdialog") + # self.assertImportable("ert_gui.pages.config.jobs.jobspanel") + # + # def test_ert_gui_pages_config_parameters(self): + # self.assertImportable("ert_gui.pages.config.parameters") + # self.assertImportable("ert_gui.pages.config.parameters.datapanel") + # self.assertImportable("ert_gui.pages.config.parameters.fieldpanel") + # self.assertImportable("ert_gui.pages.config.parameters.keywordpanel") + # self.assertImportable("ert_gui.pages.config.parameters.parameterdialog") + # self.assertImportable("ert_gui.pages.config.parameters.parametermodels") + # self.assertImportable("ert_gui.pages.config.parameters.parameterpanel") + # + # def test_ert_gui_pages_config_simulations(self): + # self.assertImportable("ert_gui.pages.config.simulations") + # self.assertImportable("ert_gui.pages.config.simulations.runpathpanel") + # self.assertImportable("ert_gui.pages.config.simulations.runtemplatepanel") diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_import.py b/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_import.py index e36e9847ad..e8fa9b72ca 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_import.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/test_ert_import.py @@ -14,7 +14,6 @@ # # See the GNU General Public License at # for more details. -import traceback from ert_tests import ExtendedTestCase @@ -26,15 +25,20 @@ class ErtImportTest(ExtendedTestCase): def test_ert_config(self): self.assertImportable("ert.config") - self.assertImportable("ert.config.config_enums") + self.assertImportable("ert.config.content_type_enum") self.assertImportable("ert.config.config_parser") + self.assertImportable("ert.config.unrecognized_enum") + def test_ert_cwrap(self): self.assertImportable("ert.cwrap") + self.assertImportable("ert.cwrap.basecclass") + self.assertImportable("ert.cwrap.basecenum") self.assertImportable("ert.cwrap.cclass") self.assertImportable("ert.cwrap.cenum") self.assertImportable("ert.cwrap.cfile") self.assertImportable("ert.cwrap.clib") + self.assertImportable("ert.cwrap.cnamespace") self.assertImportable("ert.cwrap.cwrap") def test_ert_ecl(self): @@ -54,6 +58,8 @@ class ErtImportTest(ExtendedTestCase): self.assertImportable("ert.ecl.ecl_rft_cell") self.assertImportable("ert.ecl.ecl_subsidence") self.assertImportable("ert.ecl.ecl_sum") + self.assertImportable("ert.ecl.ecl_sum_node") + self.assertImportable("ert.ecl.ecl_sum_vector") self.assertImportable("ert.ecl.ecl_util") self.assertImportable("ert.ecl.fortio") @@ -63,35 +69,40 @@ class ErtImportTest(ExtendedTestCase): self.assertImportable("ert.enkf.analysis_config") self.assertImportable("ert.enkf.block_obs") self.assertImportable("ert.enkf.ecl_config") - self.assertImportable("ert.enkf.enkf") - self.assertImportable("ert.enkf.enkf_config_node") self.assertImportable("ert.enkf.enkf_enum") self.assertImportable("ert.enkf.enkf_fs") self.assertImportable("ert.enkf.enkf_main") - self.assertImportable("ert.enkf.enkf_node") self.assertImportable("ert.enkf.enkf_obs") self.assertImportable("ert.enkf.enkf_state") self.assertImportable("ert.enkf.ens_config") self.assertImportable("ert.enkf.ert_template") self.assertImportable("ert.enkf.ert_templates") - self.assertImportable("ert.enkf.field") - self.assertImportable("ert.enkf.field_config") - self.assertImportable("ert.enkf.gen_data_config") - self.assertImportable("ert.enkf.gen_kw_config") - self.assertImportable("ert.enkf.libenkf") self.assertImportable("ert.enkf.local_config") self.assertImportable("ert.enkf.model_config") - self.assertImportable("ert.enkf.obs_vector") - self.assertImportable("ert.enkf.plot_conf") + self.assertImportable("ert.enkf.plot_config") self.assertImportable("ert.enkf.site_config") - self.assertImportable("ert.enkf.time_map") - def test_ert_ert(self): - self.assertImportable("ert.ert") - self.assertImportable("ert.ert.c_enums") - self.assertImportable("ert.ert.enums") - self.assertImportable("ert.ert.erttypes") - self.assertImportable("ert.ert.ertwrapper") + + def test_ert_enkf_data(self): + self.assertImportable("ert.enkf.data") + self.assertImportable("ert.enkf.data.enkf_config_node") + self.assertImportable("ert.enkf.data.enkf_node") + self.assertImportable("ert.enkf.data.field") + self.assertImportable("ert.enkf.data.field_config") + self.assertImportable("ert.enkf.data.gen_data_config") + self.assertImportable("ert.enkf.data.gen_kw_config") + self.assertImportable("ert.enkf.data.summary_config") + + def test_ert_enkf_util(self): + self.assertImportable("ert.enkf.util") + self.assertImportable("ert.enkf.util.obs_vector") + self.assertImportable("ert.enkf.util.time_map") + + # def test_ert_ert(self): + # self.assertImportable("ert.ert") + # self.assertImportable("ert.ert.c_enums") + # self.assertImportable("ert.ert.enums") + # self.assertImportable("ert.ert.ertwrapper") def test_ert_geo(self): self.assertImportable("ert.geo") @@ -114,9 +125,10 @@ class ErtImportTest(ExtendedTestCase): def test_ert_sched(self): self.assertImportable("ert.sched") self.assertImportable("ert.sched.history") + self.assertImportable("ert.sched.history_source_enum") self.assertImportable("ert.sched.sched_file") - def test_ert_sched(self): + def test_ert_util(self): self.assertImportable("ert.util") self.assertImportable("ert.util.buffer") self.assertImportable("ert.util.ctime") @@ -127,6 +139,7 @@ class ErtImportTest(ExtendedTestCase): self.assertImportable("ert.util.matrix") self.assertImportable("ert.util.stat") self.assertImportable("ert.util.stringlist") + self.assertImportable("ert.util.substitution_list") self.assertImportable("ert.util.test_area") self.assertImportable("ert.util.tvector") self.assertImportable("ert.util.util_func") diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_hash.py b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_hash.py new file mode 100644 index 0000000000..1cee587b08 --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_hash.py @@ -0,0 +1,75 @@ +from ctypes import c_void_p +from ert.util import Hash, StringHash, DoubleHash, IntegerHash +from ert_tests import ExtendedTestCase + + +class HashTest(ExtendedTestCase): + def test_string_hash(self): + hash = StringHash() + + self.assertEqual(len(hash), 0) + + hash["hipp"] = "" + + self.assertEqual(len(hash), 1) + + with self.assertRaises(ValueError): + hash["hopp"] = 55 + + with self.assertRaises(KeyError): + hopp = hash["hopp"] + + + + self.assertTrue("hipp" in hash) + + self.assertEqual(list(hash.keys()), ["hipp"]) + + def test_int_hash(self): + hash = IntegerHash() + + with self.assertRaises(ValueError): + hash["one"] = "ein" + + with self.assertRaises(ValueError): + hash["one"] = 1.0 + + hash["two"] = 2 + + self.assertEqual(hash["two"], 2) + + + def test_double_hash(self): + hash = DoubleHash() + + with self.assertRaises(ValueError): + hash["one"] = "ein" + + hash["two"] = 2 + hash["three"] = 3.0 + + self.assertEqual(hash["two"], 2) + self.assertEqual(hash["three"], 3.0) + + + + def test_c_void_p_hash(self): + hash = Hash() + + cp = c_void_p(512) + hash["1"] = cp + + self.assertEqual(hash["1"], cp.value) + + def test_for_in_hash(self): + hash = StringHash() + + hash["one"] = "one" + hash["two"] = "two" + hash["three"] = "three" + + for key in hash: + self.assertTrue(key in hash) + + + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_latex.py b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_latex.py index 35d8d6d13a..297cac9108 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_latex.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_latex.py @@ -1,6 +1,7 @@ import os from unittest2 import skip from ert.util import LaTeX +from ert.util.test_area import TestAreaContext from ert_tests import ExtendedTestCase @@ -18,13 +19,15 @@ class LatexTest(ExtendedTestCase): lx = LaTeX("%s/test_error.tex" % self.local_path) self.assertFalse(lx.compile()) - @skip("Unknown errors!") + #@skip("Unknown errors!") def test_cleanup( self ): - lx = LaTeX("%s/report_OK.tex" % self.statoil_path, in_place=True) - self.assertTrue(lx.in_place) - self.assertTrue(lx.compile()) - for ext in ["log", "aux", "nav", "out", "snm", "toc"]: - self.assertFalse(os.path.exists("%s/report_OK.%s" % (self.statoil_path, ext))) + with TestAreaContext("latex") as work_area: + work_area.copy_directory_content(self.statoil_path) + lx = LaTeX("report_OK.tex", in_place=True) + self.assertTrue(lx.in_place) + self.assertTrue(lx.compile()) + for ext in ["log", "aux", "nav", "out", "snm", "toc"]: + self.assertFalse(os.path.exists("report_OK.%s" % ext)) lx = LaTeX("%s/report_OK.tex" % self.statoil_path, in_place=False) self.assertFalse(lx.in_place) @@ -38,7 +41,7 @@ class LatexTest(ExtendedTestCase): self.assertTrue(os.path.exists("%s/report_OK.log" % run_path)) - @skip("Unknown errors!") + #@skip("Unknown errors!") def test_report(self): lx = LaTeX("%s/report_error.tex" % self.statoil_path) lx.timeout = 4 @@ -47,7 +50,7 @@ class LatexTest(ExtendedTestCase): lx = LaTeX("%s/report_OK.tex" % self.statoil_path) self.assertTrue(lx.compile()) - @skip("Unknown errors!") + #@skip("Unknown errors!") def test_target(self): lx = LaTeX("%s/report_OK.tex" % self.statoil_path) self.assertTrue(lx.compile()) diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_string_list.py b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_string_list.py index f5fa635290..ac077299e7 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_string_list.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_string_list.py @@ -72,4 +72,13 @@ class StringListTest(TestCase): def test_append(self): s = StringList(["A", "B"]) s.append("C") - self.assertEqual(list(s), ["A", "B", "C"]) \ No newline at end of file + self.assertEqual(list(s), ["A", "B", "C"]) + + def test_negative_index(self): + s = StringList(["A", "B", "C"]) + + self.assertEqual(s[-1], "C") + self.assertEqual(s[-3], "A") + + with self.assertRaises(LookupError): + s = s[-4] \ No newline at end of file diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_substitution_list.py b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_substitution_list.py new file mode 100644 index 0000000000..27cc56bf05 --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_substitution_list.py @@ -0,0 +1,24 @@ +from ert.util import SubstitutionList +from ert_tests import ExtendedTestCase + + +class SubstitutionListTest(ExtendedTestCase): + def test_substitution_list(self): + subst_list = SubstitutionList() + + subst_list.addItem("Key", "Value", "Doc String") + + self.assertEqual(len(subst_list), 1) + + with self.assertRaises(IndexError): + item = subst_list["1"] + + with self.assertRaises(IndexError): + item = subst_list[2] + + key, value, doc_string = subst_list[0] + + self.assertEqual(key, "Key") + self.assertEqual(value, "Value") + self.assertEqual(doc_string, "Doc String") + diff --git a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_vectors.py b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_vectors.py index e056db9fea..c37609a1a9 100644 --- a/ThirdParty/Ert/devel/python/test/ert_tests/util/test_vectors.py +++ b/ThirdParty/Ert/devel/python/test/ert_tests/util/test_vectors.py @@ -192,12 +192,6 @@ class UtilTest(TestCase): self.assertTrue(iv) - def test_asPythonObject(self): - v = DoubleVector.asPythonObject(0, DoubleVector.free) - - self.assertIsInstance(v, DoubleVector) - self.assertIsNotNone(v.cfree) - def test_time_vector(self): time_vector = TimeVector() diff --git a/ThirdParty/Ert/devel/python/test/test-data/local/simple_config/minimum_config b/ThirdParty/Ert/devel/python/test/test-data/local/simple_config/minimum_config new file mode 100644 index 0000000000..0e602437f7 --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/test-data/local/simple_config/minimum_config @@ -0,0 +1,6 @@ +JOBNAME Job%d +RUNPATH /tmp/simulations/run%d +NUM_REALIZATIONS 1 + + +JOB_SCRIPT script.sh diff --git a/ThirdParty/Ert/devel/python/test/test-data/local/simple_config/script.sh b/ThirdParty/Ert/devel/python/test/test-data/local/simple_config/script.sh new file mode 100644 index 0000000000..441bae5d2b --- /dev/null +++ b/ThirdParty/Ert/devel/python/test/test-data/local/simple_config/script.sh @@ -0,0 +1,2 @@ +#!/bin/sh +ls \ No newline at end of file