def test_custom_kw_config_define_and_read(self):
data_1 = {"VALUE_1": 123453.3, "VALUE_2": 0.234234}
data_2 = {"VALUE_1": 965689, "VALUE_3": 1.1222}
with TestAreaContext("python/enkf/data/custom_kw_config") as test_area:
self.createResultFile("result_file_1", data_1)
self.createResultFile("result_file_2", data_2)
custom_kw_config = CustomKWConfig("CUSTOM_KW", "result_file")
result_1 = StringList()
success = custom_kw_config.parseResultFile("result_file_1",
result_1)
self.assertTrue(success)
result_2 = StringList()
success = custom_kw_config.parseResultFile("result_file_2",
result_2)
self.assertFalse(success)
for key in custom_kw_config:
self.assertTrue(key in data_1)
self.assertFalse("VALUE_3" in custom_kw_config)
def test_find_first(self):
s = StringList(["A", "B", "C"])
self.assertEqual(s.index("A"), 0)
self.assertEqual(s.index("B"), 1)
self.assertEqual(s.index("C"), 2)
self.assertEqual(s.index("D"), -1)
def __init__(self,job_script, job_name, run_path, num_cpu,
status_file, ok_file, exit_file,
done_callback_function, exit_callback_function, callback_arguments, max_runtime=None):
self.done_callback_function = done_callback_function
self.exit_callback_function = exit_callback_function
self.callback_arguments = callback_arguments
argc = 1
argv = StringList()
argv.append(run_path)
self._thread_status = ThreadStatus.READY
self._thread = None
self._mutex = Lock()
self.run_path = run_path
self._max_runtime = max_runtime
self._start_time = None
self._end_time = None
c_ptr = self._alloc(job_name, run_path, job_script, argc, argv, num_cpu,
ok_file, status_file, exit_file,
None, None, None, None)
if c_ptr is not None:
super(JobQueueNode, self).__init__(c_ptr)
else:
raise ValueError("Unable to create job node object")
def test_ior(self):
s1 = StringList(initial=["A", "B", "C"])
s2 = StringList(initial=["A", "B", "C"])
s3 = s1 | s2
self.assertEqual(s3, ["A", "B", "C"])
s1 |= s2
self.assertEqual(s1, ["A", "B", "C"])
with self.assertRaises(TypeError):
s1 |= 26
def test_append(self):
s1 = StringList(["A", "B"])
s1.append("C")
s2 = StringList(["A", "B", "C"])
self.assertEqual(s1, ["A", "B", "C"])
self.assertEqual(s1, s2)
self.assertFalse(s1 == ["A", "B", "D"])
self.assertFalse(s1 == ["A", "B", "C", "D"])
pfx = "StringList(size" # __repr__
self.assertEqual(pfx, repr(s2)[:len(pfx)])
def test_fail_init(self):
with self.assertRaises(TypeError):
StringList(initial="a string instead of a list")
with self.assertRaises(TypeError):
StringList(initial="a unicode string instead of a list")
with self.assertRaises(TypeError):
StringList(initial=b"a bytearray instead of a list")
with self.assertRaises(TypeError):
StringList(initial=[2, 4, 5])
def test_iadd(self):
s1 = StringList(initial=["A", "B", "C"])
with self.assertRaises(TypeError):
s3 = s1 + 10
s2 = StringList(initial=["A", "B", "C"])
s3 = s1 + s2
self.assertEqual(s3, ["A", "B", "C", "A", "B", "C"])
s1 += s2
self.assertEqual(s1, ["A", "B", "C", "A", "B", "C"])
with self.assertRaises(TypeError):
s3 += "b"
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]
def initializeCurrentCaseFromScratch(parameters, members):
selected_parameters = StringList(parameters)
for member in members:
member = int(member.strip())
ERT.ert.getEnkfFsManager().initializeFromScratch(
selected_parameters, member, member)
ERT.emitErtChange()
def test_custom_init_runs(state_mask, expected_length):
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
new_fs = ert.getEnkfFsManager().getFileSystem("new_case")
ert.getEnkfFsManager().switchFileSystem(new_fs)
ert.getEnkfFsManager().customInitializeCurrentFromExistingCase(
"default_0", 0, state_mask, StringList(["SNAKE_OIL_PARAM"]))
assert len(ert.getEnkfFsManager().getStateMapForCase(
"new_case")) == expected_length
def test_append_ptr(self):
arg = ArgPack(StringList())
self.assertEqual(len(arg), 1)
func = getattr(TEST_LIB, "test_argpack_is_stringlist")
func.restype = None
func.argtypes = [ArgPack]
func(arg)
def initialize(
self,
fs: EnkfFs,
param_list: Optional[StringList] = None,
init_mode=EnkfInitModeEnum.INIT_CONDITIONAL,
):
if param_list is None:
ens_config = self.ensembleConfig()
param_list = ens_config.getKeylistFromVarType(EnkfVarType.PARAMETER)
self._initialize(fs, StringList(param_list), init_mode)
def test_del(self):
s = StringList(initial=["A", "list"])
internal_list_of_strings = s.strings
python_list_of_strings = list(s)
self.assertEqual(internal_list_of_strings, python_list_of_strings)
del s
self.assertEqual(python_list_of_strings, ["A", "list"])
def test_fs_init_from_scratch_deprecated():
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
sim_fs = ert.getEnkfFsManager().getFileSystem("new_case") # new case
mask = BoolVector.createFromList(25, [0, 1, 2, 3, 4, 5])
run_context = ErtRunContext.case_init(sim_fs, mask)
with pytest.warns(DeprecationWarning):
ert.getEnkfFsManager().initializeFromScratch(
StringList(["SNAKE_OIL_PARAM"]), run_context)
assert len(ert.getEnkfFsManager().getStateMapForCase("new_case")) == 6
def test_fs_init_from_scratch():
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
sim_fs = ert.getEnkfFsManager().getFileSystem("new_case")
mask = [True] * 6 + [False] * 19
run_context = ErtRunContext.case_init(sim_fs, mask)
ert.getEnkfFsManager().initializeFromScratch(
StringList(["SNAKE_OIL_PARAM"]), run_context)
assert len(ert.getEnkfFsManager().getStateMapForCase("new_case")) == 6
def test_custom_init_runs(state_mask, expected_length):
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
new_fs = ert.getEnkfFsManager().getFileSystem("new_case") # new case
ert.getEnkfFsManager().switchFileSystem(new_fs)
index_list = [i for i, flag in enumerate(state_mask) if flag]
bool_vector = BoolVector.createFromList(len(state_mask), index_list)
ert.getEnkfFsManager().customInitializeCurrentFromExistingCase(
"default_0", 0, bool_vector, StringList(["SNAKE_OIL_PARAM"]))
assert len(ert.getEnkfFsManager().getStateMapForCase(
"new_case")) == expected_length
def initializeCurrentCaseFromExisting(source_case, target_case, source_report_step, parameters, members):
if caseExists(source_case) and caseIsInitialized(source_case) and caseExists(target_case):
total_member_count = getRealizationCount()
member_mask = BoolVector.createFromList(total_member_count, members)
selected_parameters = StringList(parameters)
ERT.ert.getEnkfFsManager().customInitializeCurrentFromExistingCase(source_case, source_report_step, member_mask,
selected_parameters)
ERT.emitErtChange()
def initializeCurrentCaseFromScratch(parameters, members):
selected_parameters = StringList(parameters)
mask = BoolVector(initial_size = getRealizationCount(), default_value = False)
for member in members:
member = int(member.strip())
mask[member] = True
sim_fs = ERT.ert.getEnkfFsManager().getCurrentFileSystem()
run_context = ErtRunContext.case_init(sim_fs, mask)
ERT.ert.getEnkfFsManager().initializeFromScratch(selected_parameters, run_context)
ERT.emitErtChange()
def __init__(self, job_script, job_name, run_path, num_cpu, status_file,
ok_file, exit_file, done_callback_function,
exit_callback_function, callback_arguments):
self.done_callback_function = done_callback_function
self.exit_callback_function = exit_callback_function
self.callback_arguments = callback_arguments
argc = 1
argv = StringList()
argv.append(run_path)
self.started = False
self.run_path = run_path
c_ptr = self._alloc(job_name, run_path, job_script, argc, argv,
num_cpu, ok_file, status_file, exit_file, None,
None, None, None)
if c_ptr is not None:
super(JobQueueNode, self).__init__(c_ptr)
else:
raise ValueError("Unable to create job node object")
def load(cls,
smspec_file,
unsmry_file,
key_join_string=":",
include_restart=True):
if not os.path.isfile(smspec_file):
raise IOError("No such file: %s" % smspec_file)
if not os.path.isfile(unsmry_file):
raise IOError("No such file: %s" % unsmry_file)
data_files = StringList()
data_files.append(unsmry_file)
c_ptr = cls._fread_alloc(smspec_file, data_files, key_join_string,
include_restart)
if c_ptr is None:
raise IOError("Failed to create summary instance")
ecl_sum = cls.createPythonObject(c_ptr)
ecl_sum._load_case = smspec_file
return ecl_sum
def initializeCurrentCaseFromScratch(
parameters: List[str], members: List[str], ert: EnKFMain
):
selected_parameters = StringList(parameters)
mask = [False] * ert.getEnsembleSize()
for member in members:
member = int(member.strip())
mask[member] = True
sim_fs = ert.getEnkfFsManager().getCurrentFileSystem()
run_context = ErtRunContext.case_init(sim_fs, mask)
ert.getEnkfFsManager().initializeFromScratch(selected_parameters, run_context)
def mock_ert(monkeypatch):
ert_mock = MagicMock()
string_list = StringList(["forward_model_1", "forward_model_2"])
ert_mock.getModelConfig.return_value.getForwardModel.return_value.joblist.return_value = ( # noqa
string_list)
ert_mock.ensembleConfig.return_value.getKeylistFromVarType.return_value = [
"param_1",
"param_2",
]
yield ert_mock
def test_create(self):
arg = ArgPack()
self.assertEqual(len(arg), 0)
arg.append(StringList())
self.assertEqual(len(arg), 1)
arg.append(3.14)
self.assertEqual(len(arg), 2)
o = object()
with self.assertRaises(TypeError):
arg.append(o)
def test_custom_kw_config_parse_fail(self):
data = {"KEY_1": "Value Key_2"}
with TestAreaContext(
"python/enkf/data/custom_kw_config_fail") as test_area:
self.createResultFile("result_file", data)
custom_kw_config = CustomKWConfig("CUSTOM_KW_FAIL", "result_file")
self.assertIsNone(custom_kw_config.getOutputFile())
self.assertFalse(
custom_kw_config.parseResultFile("result_file", StringList()))
def mock_ert_summary(monkeypatch, autouse=True):
ERT_mock = MagicMock()
test_module = inspect.getmodule(ErtSummary)
monkeypatch.setattr(test_module, "ERT", ERT_mock)
string_list = StringList(["forward_model_1", "forward_model_2"])
ERT_mock.ert.getModelConfig.return_value.getForwardModel.return_value.joblist.return_value = (
string_list)
ERT_mock.ert.ensembleConfig.return_value.getKeylistFromVarType.return_value = [
"param_1",
"param_2",
]
def test_iterate(self):
s = ["A", "list", "of", "strings"]
s1 = StringList(initial=s)
s2 = s1.strings
s3 = list(s1)
for index in range(len(s1)):
self.assertEqual(s[index], s1[index])
for index in range(len(s2)):
self.assertEqual(s[index], s2[index])
for index in range(len(s3)):
self.assertEqual(s[index], s3[index])
def __init__(self, key, input_keys):
"""Create an ExtParamConfig for @key with the given @input_keys
@input_keys can be either a list of keys as strings or a dict with
keys as strings and a list of suffixes for each key.
If a list of strings is given, the order is preserved.
"""
try:
keys = input_keys.keys() # extract keys if suffixes are also given
suffixmap = input_keys.items()
except AttributeError:
keys = input_keys # assume list of keys
suffixmap = {}
if len(keys) != len(set(keys)):
raise ValueError("Duplicate keys for key '{}' - keys: {}".format(
key, keys))
keys = StringList(initial=input_keys)
c_ptr = self._alloc(key, keys)
super().__init__(c_ptr)
for k, suffixes in suffixmap:
suffixlist = StringList(initial=suffixes)
if len(suffixes) == 0:
raise ValueError(
"No suffixes for key '{}/{}' - suffixes: {}".format(
key, k, suffixes))
if len(suffixes) != len(set(suffixes)):
raise ValueError(
"Duplicate suffixes for key '{}/{}' - suffixes: {}".format(
key, k, suffixes))
if any(len(s) == 0 for s in suffixes):
raise ValueError(
"Empty suffix encountered for key '{}/{}' - suffixes: {}".
format(key, k, suffixes))
self._ikey_set_suffixes(self._key_index(k), suffixlist)
def keys(self, pattern=None):
"""
Return a StringList of summary keys matching @pattern.
The matching algorithm is ultimately based on the fnmatch()
function, i.e. normal shell-character syntax is used. With
@pattern == "WWCT:*" you will get a list of watercut keys for
all wells.
If pattern is None you will get all the keys of summary
object.
"""
s = StringList()
self._select_matching_keys(pattern, s)
return s
def test_last(self):
s = StringList(initial=["A", "list", "of", "strings"])
self.assertEqual(s.last, "strings")
with self.assertRaises(IndexError):
s.pop()
s.pop()
s.pop()
s.pop()
s.last
def test_pop(self):
s = StringList(initial=["A", "list", "of", "strings"])
s1 = s.pop()
self.assertTrue(len(s) == 3)
self.assertTrue(s1 == "strings")
s1 = s.pop()
self.assertTrue(len(s) == 2)
self.assertTrue(s1 == "of")
s1 = s.pop()
self.assertTrue(len(s) == 1)
self.assertTrue(s1 == "list")
s1 = s.pop()
self.assertTrue(len(s) == 0)
self.assertTrue(s1 == "A")
with self.assertRaises(IndexError):
s.pop()
