def test_run_context(self):
with TestAreaContext("enkf_test") as work_area:
work_area.copy_directory(self.case_directory)
main = EnKFMain("simple_config/minimum_config")
fs_manager = main.getEnkfFsManager()
fs = fs_manager.getCurrentFileSystem()
iactive = BoolVector(initial_size=10, default_value=True)
iactive[0] = False
iactive[1] = False
run_context = main.getRunContextENSEMPLE_EXPERIMENT(fs, iactive)
self.assertEqual(len(run_context), 8)
with self.assertRaises(IndexError):
run_context[8]
with self.assertRaises(TypeError):
run_context["String"]
run_arg = run_context[0]
self.assertTrue(isinstance(run_arg, RunArg))
with self.assertRaises(ValueError):
run_context.iensGet(0)
with self.assertRaises(ValueError):
run_context.iensGet(1)
arg0 = run_context[0]
arg2 = run_context.iensGet(2)
def test_with_enkf_fs(self):
config_file = self.createTestPath("Statoil/config/with_data/config")
with TestAreaContext("enkf/summary_key_set/enkf_fs",
store_area=True) as context:
context.copy_parent_content(config_file)
fs = EnkfFs("storage/default")
summary_key_set = fs.getSummaryKeySet()
summary_key_set.addSummaryKey("FOPT")
summary_key_set.addSummaryKey("WWCT")
summary_key_set.addSummaryKey("WOPR")
fs.umount()
ert = EnKFMain("config")
fs = ert.getEnkfFsManager().getCurrentFileSystem()
summary_key_set = fs.getSummaryKeySet()
self.assertTrue("FOPT" in summary_key_set)
self.assertTrue("WWCT" in summary_key_set)
self.assertTrue("WOPR" in summary_key_set)
ensemble_config = ert.ensembleConfig()
self.assertTrue("FOPT" in ensemble_config)
self.assertTrue("WWCT" in ensemble_config)
self.assertTrue("WOPR" in ensemble_config)
self.assertFalse("TCPU" in ensemble_config)
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.assertIsInstance(main.ensembleConfig(), EnsembleConfig)
self.assertIsInstance(main.analysisConfig(), AnalysisConfig)
self.assertIsInstance(main.getModelConfig(), ModelConfig)
#self.assertIsInstance(main.local_config(), LocalConfig) #warn: Should this be None?
self.assertIsInstance(main.siteConfig(), SiteConfig)
self.assertIsInstance(main.eclConfig(), EclConfig)
self.assertIsInstance(main.plotConfig(), PlotConfig)
# self.main.load_obs(obs_config_file)
self.assertIsInstance(main.getObservations(), EnkfObs)
self.assertIsInstance(main.get_templates(), ErtTemplates)
self.assertIsInstance(
main.getEnkfFsManager().getCurrentFileSystem(), EnkfFs)
# self.assertIsInstance(main.iget_member_config(0), MemberConfig)
self.assertIsInstance(main.getMemberRunningState(0), EnKFState)
self.assertEqual("Ensemble", main.getMountPoint())
main.free()
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")
main.free()
def test_repr(self):
with TestAreaContext("enkf_test", store_area=True) as work_area:
work_area.copy_directory(self.case_directory)
main = EnKFMain("simple_config/minimum_config")
pfx = 'EnKFMain(ensemble_size'
self.assertEqual(pfx, repr(main)[:len(pfx)])
main.free()
def test_enkf_state(self):
with TestAreaContext("enkf_library_test") as work_area:
work_area.copy_directory(self.case_directory)
main = EnKFMain("simple_config/minimum_config", self.site_config)
state = main.getRealisation(0)
with self.assertRaises(TypeError):
state.addSubstKeyword("GEO_ID", 45)
state.addSubstKeyword("GEO_ID", "45")
def test_enkf_create_config_file(self):
config_file = "test_new_config"
dbase_type = "BLOCK_FS"
num_realizations = 42
with TestAreaContext("python/ens_condif/create_config",
store_area=True) as ta:
EnKFMain.createNewConfig(config_file, "storage", dbase_type,
num_realizations)
main = EnKFMain(config_file)
self.assertEqual(main.getEnsembleSize(), num_realizations)
def test_observations(self):
with TestAreaContext("enkf_test") as work_area:
work_area.copy_directory(self.case_directory)
main = EnKFMain("simple_config/minimum_config")
count = 10
summary_key = "test_key"
observation_key = "test_obs_key"
summary_observation_node = EnkfConfigNode.createSummaryConfigNode(
summary_key, LoadFailTypeEnum.LOAD_FAIL_EXIT)
observation_vector = ObsVector(
EnkfObservationImplementationType.SUMMARY_OBS, observation_key,
summary_observation_node, count)
main.getObservations().addObservationVector(observation_vector)
values = []
for index in range(0, count):
value = index * 10.5
std = index / 10.0
summary_observation_node = SummaryObservation(
summary_key, observation_key, value, std)
observation_vector.installNode(index, summary_observation_node)
self.assertEqual(observation_vector.getNode(index),
summary_observation_node)
self.assertEqual(value, summary_observation_node.getValue())
values.append((index, value, std))
observations = main.getObservations()
test_vector = observations[observation_key]
index = 0
for node in test_vector:
self.assertTrue(isinstance(node, SummaryObservation))
self.assertEqual(node.getValue(), index * 10.5)
index += 1
self.assertEqual(observation_vector, test_vector)
for index, value, std in values:
self.assertTrue(test_vector.isActive(index))
summary_observation_node = test_vector.getNode(index)
"""@type: SummaryObservation"""
self.assertEqual(value, summary_observation_node.getValue())
self.assertEqual(
std, summary_observation_node.getStandardDeviation())
self.assertEqual(summary_key,
summary_observation_node.getSummaryKey())
main.free()
def test_ecl_config_creation(self):
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.analysisConfig(), AnalysisConfig)
self.assertIsInstance(main.eclConfig(), EclConfig)
with self.assertRaises(AssertionError): # Null pointer!
self.assertIsInstance(main.eclConfig().getRefcase(), EclSum)
file_system = main.getEnkfFsManager().getCurrentFileSystem()
self.assertEqual(file_system.getCaseName(), "default")
time_map = file_system.getTimeMap()
self.assertIsInstance(time_map, TimeMap)
main.free()
