def test_analysis_module(self): rng = RandomNumberGenerator() module = self.createAnalysisModule() ens_size = 12 obs_size = 1 state_size = 2 true_params = [1.25, 0.75] true_state = forward_model(true_params) obs = [(measure(true_state), 0.75)] A = Matrix(state_size, ens_size) ens = [] for iens in range(ens_size): param = [random.gauss(1.00, 1.00), random.gauss(1.00, 1.00)] ens.append(param) ens_mask = BoolVector(default_value=True, initial_size=ens_size) ens_mask[2] = False obs_mask = BoolVector() obs_mask[0] = 1 (A, S, E, D, R, dObs) = init_matrices(ens, ens_mask, obs, rng) module.initUpdate(ens_mask, obs_mask, S, R, dObs, E, D, rng) module.updateA(A, S, R, dObs, E, D, rng) ens_mask[10] = False ens_mask[5] = False (A, S, E, D, R, dObs) = init_matrices(ens, ens_mask, obs, rng) self.assertEqual(S.dims(), (obs_size, ens_mask.countEqual(True))) self.assertEqual(E.dims(), (obs_size, ens_mask.countEqual(True))) self.assertEqual(D.dims(), (obs_size, ens_mask.countEqual(True))) module.initUpdate(ens_mask, obs_mask, S, R, dObs, E, D, rng) module.updateA(A, S, R, dObs, E, D, rng)
def test_update_active_mask(self): vec = BoolVector(False, 10) self.assertTrue(vec.updateActiveMask("1-2,5")) self.assertTrue(vec[1]) self.assertTrue(vec[2]) self.assertTrue(vec[5]) self.assertFalse(vec[4]) vec = BoolVector(False, 10) self.assertTrue(vec.updateActiveMask("1-5,2,3")) self.assertTrue(vec[1]) self.assertTrue(vec[2]) self.assertTrue(vec[3]) self.assertTrue(vec[4]) self.assertTrue(vec[5]) self.assertFalse(vec[0]) self.assertFalse(vec[6]) vec = BoolVector(False, 10) self.assertTrue(vec.updateActiveMask("5,6,7,15")) self.assertTrue(vec[5]) self.assertTrue(vec[6]) self.assertTrue(vec[7]) self.assertFalse(vec[4]) self.assertFalse(vec[8]) self.assertEqual(len(vec), 16)
def test_simulation_model(self): with TestAreaContext('enkf_test_sim_model_kw') as work_area: base_path = os.getcwd() source_path = self.createTestPath('local/simulation_model') work_area.copy_directory(source_path) dir_ert = os.path.join(base_path, 'simulation_model') assert (os.path.isdir(dir_ert)) file_ert = os.path.join(dir_ert, 'sim_kw.ert') assert (os.path.isfile(file_ert)) with ErtTestContext("sim_kw", model_config=file_ert, store_area=True) as ctx: ert = ctx.getErt() fs_manager = ert.getEnkfFsManager() result_fs = fs_manager.getCurrentFileSystem() model_config = ert.getModelConfig() forward_model = model_config.getForwardModel() self.assertEqual(forward_model.get_size(), 4) self.assertEqual( forward_model.iget_job(3).get_arglist(), ['WORD_A']) self.assertEqual( forward_model.iget_job(0).get_arglist(), ['<ARGUMENT>']) self.assertEqual( forward_model.iget_job(1).get_arglist(), ['Hello', 'True', '3.14', '4']) self.assertEqual( forward_model.iget_job(2).get_arglist(), ['word', '<ECLBASE>']) runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = ert.getDataKW() itr = 0 mask = BoolVector(default_value=True, initial_size=1) run_context = ErtRunContext.ensemble_experiment( result_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) ert.getEnkfSimulationRunner().createRunPath(run_context) queue_config = ert.get_queue_config() self.assertEqual(queue_config.num_cpu, 5) os.chdir('storage/sim_kw/runpath/realisation-0/iter-0') assert (os.path.isfile('jobs.json')) with open("jobs.json", "r") as f: data = json.load(f) jobList = data["jobList"] old_job_A = jobList[3] self.assertEqual(old_job_A["argList"], ['WORD_A']) old_job_B = jobList[0] self.assertEqual(old_job_B["argList"], ['yy']) new_job_A = jobList[1] self.assertEqual(new_job_A["argList"], ['Hello', 'True', '3.14', '4']) new_job_B = jobList[2] self.assertEqual(new_job_B["argList"], ['word', 'SIM_KW'])
def test_it(self): state_size = 10 with ErtTestContext("update", self.config_file) as tc: analysis = self.createAnalysisModule() ert = tc.getErt() obs = ert.getObservations() local_obsdata = obs.getAllActiveLocalObsdata() fs = ert.getEnkfFsManager().getCurrentFileSystem() mask = BoolVector(initial_size=ert.getEnsembleSize(), default_value=True) meas_data = MeasData(mask) obs_data = ObsData() obs.getObservationAndMeasureData( fs, local_obsdata, mask.createActiveList(), meas_data, obs_data ) update(self.rng, mask, analysis, ert, meas_data, obs_data, state_size) mask[0] = False mask[4] = False meas_data = MeasData(mask) obs_data = ObsData() obs.getObservationAndMeasureData( fs, local_obsdata, mask.createActiveList(), meas_data, obs_data ) update(self.rng, mask, analysis, ert, meas_data, obs_data, state_size)
def test_assert_export(self): with ErtTestContext( "create_runpath_export", self.createTestPath("local/snake_oil_no_data/snake_oil.ert"), ) as tc: ert = tc.getErt() runpath_list = ert.getRunpathList() self.assertFalse(os.path.isfile(runpath_list.getExportFile())) ens_size = ert.getEnsembleSize() runner = ert.getEnkfSimulationRunner() fs_manager = ert.getEnkfFsManager() init_fs = fs_manager.getFileSystem("init_fs") mask = BoolVector(initial_size=25, default_value=True) runpath_fmt = ert.getModelConfig().getRunpathFormat() subst_list = SubstitutionList() itr = 0 jobname_fmt = ert.getModelConfig().getJobnameFormat() run_context1 = ErtRunContext( EnkfRunType.INIT_ONLY, init_fs, None, mask, runpath_fmt, jobname_fmt, subst_list, itr, ) runner.createRunPath(run_context1) self.assertTrue(os.path.isfile(runpath_list.getExportFile())) self.assertEqual("test_runpath_list.txt", os.path.basename(runpath_list.getExportFile()))
def getSimulationArguments(self): return { "active_realizations": BoolVector( default_value=True, initial_size=self.number_of_realizations ), "config_file": self.config_file, }
def test_assert_symlink_deleted(self): with ErtTestContext("create_runpath_symlink_deleted" , self.createTestPath("local/snake_oil_field/snake_oil.ert")) as tc: ert = tc.getErt( ) runpath_list = ert.getRunpathList( ) ens_size = ert.getEnsembleSize() runner = ert.getEnkfSimulationRunner() mask = BoolVector( initial_size = ens_size , default_value = True ) fs_manager = ert.getEnkfFsManager() init_fs = fs_manager.getFileSystem("init_fs") # create directory structure runpath_fmt = ert.getModelConfig().getRunpathFormat( ) subst_list = SubstitutionList( ) itr = 0 jobname_fmt = ert.getModelConfig().getJobnameFormat() run_context = ErtRunContext( EnkfRunType.INIT_ONLY , init_fs, None , mask , runpath_fmt, jobname_fmt, subst_list , itr ) runner.createRunPath( run_context ) # replace field file with symlink linkpath = '%s/permx.grdcel' % str(runpath_list[0].runpath) targetpath = '%s/permx.grdcel.target' % str(runpath_list[0].runpath) open(targetpath, 'a').close() os.remove(linkpath) os.symlink(targetpath, linkpath) # recreate directory structure runner.createRunPath( run_context ) # ensure field symlink is replaced by file self.assertFalse( os.path.islink(linkpath) )
def test_load_results_from_run_context(self): with ErtTestContext("manual_load_test", self.config_file) as test_context: ert = test_context.getErt() load_into_case = "A1" load_from_case = "default" load_into = ert.getEnkfFsManager().getFileSystem(load_into_case) load_from = ert.getEnkfFsManager().getFileSystem(load_from_case) ert.getEnkfFsManager().switchFileSystem(load_from) realisations = BoolVector(default_value=True, initial_size=25) realisations[7] = False iteration = 0 run_context = ert.getRunContextENSEMPLE_EXPERIMENT(load_into, realisations) loaded = ert.loadFromRunContext(run_context, load_into) load_into_case_state_map = load_into.getStateMap() load_into_states = [state for state in load_into_case_state_map] expected = [RealizationStateEnum.STATE_HAS_DATA] * 25 expected[7] = RealizationStateEnum.STATE_UNDEFINED self.assertListEqual(load_into_states, expected) self.assertEqual(24, loaded) self.assertEqual(25, len(expected)) self.assertEqual(25, len(realisations))
def _create_runpath(ert: LibresFacade, iteration: int = 0) -> ErtRunContext: """ Instantiate an ERT runpath. This will create the parameter coefficients. """ enkf_main = ert._enkf_main result_fs = ert.get_current_fs() target_fs = ert._enkf_main.getEnkfFsManager().getFileSystem("iter") model_config = enkf_main.getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = enkf_main.getDataKW() run_context = ErtRunContext.ensemble_smoother( result_fs, target_fs, BoolVector(default_value=True, initial_size=ert.get_ensemble_size()), runpath_fmt, jobname_fmt, subst_list, iteration, ) enkf_main.getEnkfSimulationRunner().createRunPath(run_context) return run_context
def update(self, line): arguments = splitArguments(line) if len(arguments) == 1: case_name = arguments[0] ert = self.ert() fs_manager = ert.getEnkfFsManager() ert.getEnkfSimulationRunner().runWorkflows(HookRuntime.PRE_UPDATE) es_update = ESUpdate( ert ) target_fs = fs_manager.getFileSystem(case_name) source_fs = fs_manager.getCurrentFileSystem( ) model_config = ert.getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) jobname_fmt = model_config.getJobnameFormat( ) subst_list = ert.getDataKW( ) mask = BoolVector( default_value = True, initial_size = ert.getEnsembleSize( ) ) run_context = ErtRunContext.ensemble_smoother( source_fs , target_fs , mask, runpath_fmt, jobname_fmt, subst_list, 0 ) success = es_update.smootherUpdate( run_context ) if not success: self.lastCommandFailed("Unable to perform update") ert.getEnkfSimulationRunner().runWorkflows(HookRuntime.POST_UPDATE) else: self.lastCommandFailed("Expected one argument: <target_fs> received: '%s'" % line)
def load(self, fs, report_step, input_mask=None): """ @type fs: EnkfFs @type report_step: int @type input_mask: BoolVector @rtype: PlotBlockData """ state_map = fs.getStateMap() ensemble_size = len(state_map) if not input_mask is None: mask = BoolVector.copy(input_mask) else: mask = BoolVector(False, ensemble_size) state_map.selectMatching(mask, RealizationStateEnum.STATE_HAS_DATA) depth = self.getDepthValues(report_step) self.__permutation_vector = depth.permutationSort() depth.permute(self.__permutation_vector) plot_block_data = PlotBlockData(depth) thread_pool = ThreadPool() for index in range(ensemble_size): if mask[index]: thread_pool.addTask(self.loadVector, plot_block_data, fs, report_step, index) thread_pool.nonBlockingStart() thread_pool.join() return plot_block_data
def test_run_context(self): with TestAreaContext("enkf_test") as work_area: work_area.copy_directory(self.case_directory) res_config = ResConfig("simple_config/minimum_config") main = EnKFMain(res_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), 10) with self.assertRaises(IndexError): run_context[10] with self.assertRaises(TypeError): run_context["String"] self.assertIsNone(run_context[0]) run_arg = run_context[2] self.assertTrue(isinstance(run_arg, RunArg)) rng1 = main.rng() rng1.setState("ABCDEFGHIJ012345") d1 = rng1.getDouble() rng1.setState("ABCDEFGHIJ012345") rng2 = main.rng() d2 = rng2.getDouble() self.assertEqual(d1, d2)
def test_without_gen_kw(self): case_directory = self.createTestPath("local/snake_oil_no_data/") with TestAreaContext("test_enkf_runpath", store_area=False) as work_area: work_area.copy_directory(case_directory) res_config = ResConfig("snake_oil_no_data/snake_oil_no_gen_kw.ert") main = EnKFMain(res_config) iactive = BoolVector(initial_size=main.getEnsembleSize(), default_value=False) iactive[0] = True fs = main.getEnkfFsManager().getCurrentFileSystem() run_context = main.getRunContextENSEMPLE_EXPERIMENT(fs, iactive) main.createRunpath(run_context) self.assertDirectoryExists( "snake_oil_no_data/storage/snake_oil_no_gen_kw/runpath/realisation-0/iter-0" ) self.assertFileDoesNotExist( "snake_oil_no_data/storage/snake_oil_no_gen_kw/runpath/realisation-0/iter-0/parameters.txt" ) self.assertEqual( len( os.listdir( "snake_oil_no_data/storage/snake_oil_no_gen_kw/runpath" )), 1, ) self.assertEqual( len( os.listdir( "snake_oil_no_data/storage/snake_oil_no_gen_kw/runpath/realisation-0" )), 1, )
def testObs(self): with ErtTestContext("obs_test", self.config_file) as test_context: ert = test_context.getErt() obs = ert.getObservations() self.assertEqual(32, len(obs)) for v in obs: self.assertTrue(isinstance(v, ObsVector)) self.assertEqual(obs[-1].getKey(), "RFT_TEST") self.assertEqual(obs[-1].getDataKey(), "4289383") self.assertEqual(obs[-1].getObsKey(), "RFT_TEST") with self.assertRaises(IndexError): v = obs[-40] with self.assertRaises(IndexError): v = obs[40] with self.assertRaises(KeyError): v = obs["No-this-does-not-exist"] v1 = obs["WWCT:OP_3"] v2 = obs["GOPT:OP"] mask = BoolVector(True, ert.getEnsembleSize()) current_fs = ert.getEnkfFsManager().getCurrentFileSystem() self.assertTrue(v1.hasData(mask, current_fs)) self.assertFalse(v2.hasData(mask, current_fs)) local_node = v1.createLocalObs() for t in v1.getStepList(): self.assertTrue(local_node.tstepActive(t))
def createActiveList(ert, fs): state_map = fs.getStateMap() ens_mask = BoolVector(False, ert.getEnsembleSize()) state_map.selectMatching(ens_mask, RealizationStateEnum.STATE_HAS_DATA) active_list = BoolVector.createActiveList(ens_mask) return [iens for iens in active_list]
def test_create(self): with TestAreaContext("run_context"): arg = None sim_fs = EnkfFs.createFileSystem("sim_fs", EnKFFSType.BLOCK_FS_DRIVER_ID, arg) target_fs = None mask = BoolVector(initial_size=100, default_value=True) mask[50] = False runpath_fmt = PathFormat("path/to/sim%d") subst_list = SubstitutionList() itr = 0 jobname_fmt = "job%d" run_context1 = ErtRunContext(EnkfRunType.ENSEMBLE_EXPERIMENT, sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) run_id1 = run_context1.get_id() run_arg0 = run_context1[0] with self.assertRaises(ValueError): run_arg0.getQueueIndex() self.assertEqual(run_arg0.iter_id, itr) self.assertEqual(run_id1, run_arg0.get_run_id()) run_context2 = ErtRunContext(EnkfRunType.ENSEMBLE_EXPERIMENT, sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) run_id2 = run_context2.get_id() self.assertFalse(run_id1 == run_id2) self.assertTrue(run_context1.is_active(49)) self.assertFalse(run_context1.is_active(50))
def test_bool_vector(self): b = BoolVector() b.setDefault(True) b[4] = False self.assertEqual(list(b), [True, True, True, True, False])
def test_update(self): key = "OBS" obs_size = 4 ens_size = 10 ens_mask = BoolVector(default_value=True, initial_size=ens_size) block = MeasBlock(key, obs_size, ens_mask) with self.assertRaises(TypeError): block["String"] = 10 with self.assertRaises(TypeError): block[10] = 10 with self.assertRaises(IndexError): block[obs_size, 0] = 10 with self.assertRaises(IndexError): block[0, ens_size] = 10 #----------------------------------------------------------------- with self.assertRaises(TypeError): a = block["String"] with self.assertRaises(TypeError): a = block[10] with self.assertRaises(IndexError): val = block[obs_size, 0] with self.assertRaises(IndexError): val = block[0, ens_size] block[1, 2] = 3 self.assertEqual(3, block[1, 2])
def test_with_gen_kw(self): case_directory = self.createTestPath('local/snake_oil_no_data/') with TestAreaContext('test_enkf_runpath', store_area=True) as work_area: work_area.copy_directory(case_directory) res_config = ResConfig('snake_oil_no_data/snake_oil.ert') main = EnKFMain(res_config) iactive = BoolVector(initial_size=main.getEnsembleSize(), default_value=False) iactive[0] = True fs = main.getEnkfFsManager().getCurrentFileSystem() run_context = main.getRunContextENSEMPLE_EXPERIMENT(fs, iactive) main.createRunpath(run_context) self.assertFileExists( 'snake_oil_no_data/storage/snake_oil/runpath/realisation-0/iter-0/parameters.txt' ) self.assertEqual( len(os.listdir('snake_oil_no_data/storage/snake_oil/runpath')), 1) self.assertEqual( len( os.listdir( 'snake_oil_no_data/storage/snake_oil/runpath/realisation-0' )), 1) rp = main.create_runpath_list() self.assertEqual(len(rp), 0) rp.load() self.assertEqual(len(rp), 1)
def test_simulated_custom_kw(self): config = self.createTestPath("local/custom_kw/mini_config") with ErtTestContext("python/enkf/data/custom_kw_simulated", config) as context: ert = context.getErt() ensemble_config = ert.ensembleConfig() self.assertTrue("AGGREGATED" in ensemble_config) config = ensemble_config.getNode("AGGREGATED").getCustomKeywordModelConfig() self.assertEqual(len(config.getKeys()), 0) simulation_runner = EnkfSimulationRunner(ert) job_queue = ert.get_queue_config().create_job_queue() iteration_count = 0 active = BoolVector(default_value = True, initial_size = 4) subst_list = ert.getDataKW( ) runpath_fmt = ert.getModelConfig( ).getRunpathFormat( ) fs_manager = ert.getEnkfFsManager( ) fs = fs_manager.getFileSystem("fs") jobname_fmt = ert.getModelConfig( ).getJobnameFormat( ) run_context = ErtRunContext( EnkfRunType.ENSEMBLE_EXPERIMENT , fs, None , active , runpath_fmt, jobname_fmt, subst_list , iteration_count) simulation_runner.createRunPath( run_context ) simulation_runner.runEnsembleExperiment(job_queue, run_context) config = ensemble_config.getNode("AGGREGATED").getCustomKeywordModelConfig() self.assertEqual(len(config.getKeys()), 4) self.assertItemsEqual(config.getKeys(), ["PERLIN_1", "PERLIN_2", "PERLIN_3", "STATE"])
def test_update(self): config = self.createTestPath("local/snake_oil/snake_oil.ert") with ErtTestContext("update_test", config) as context: ert = context.getErt() es_update = ESUpdate(ert) fsm = ert.getEnkfFsManager() sim_fs = fsm.getFileSystem("default_0") target_fs = fsm.getFileSystem("target") mask = BoolVector(initial_size=ert.getEnsembleSize(), default_value=True) run_context = ErtRunContext.ensemble_smoother_update(sim_fs, target_fs) es_update.smootherUpdate(run_context) conf = ert.ensembleConfig()["SNAKE_OIL_PARAM"] sim_node = EnkfNode(conf) target_node = EnkfNode(conf) node_id = NodeId(0, 0) sim_node.load(sim_fs, node_id) target_node.load(target_fs, node_id) sim_gen_kw = sim_node.asGenKw() target_gen_kw = target_node.asGenKw() # Test that an update has actually taken place for index in range(len(sim_gen_kw)): self.assertNotEqual(sim_gen_kw[index], target_gen_kw[index])
def test_localization(self): config = self.createTestPath("local/snake_oil/snake_oil.ert") with ErtTestContext("localization_test", config) as context: ert = context.getErt() es_update = ESUpdate(ert) fsm = ert.getEnkfFsManager() sim_fs = fsm.getFileSystem("default_0") target_fs = fsm.getFileSystem("target") # perform localization localized_idxs = (1, 2) local_config = ert.getLocalConfig() local_config.clear() dataset = local_config.createDataset("DATASET_SCALAR_LOCA") dataset.addNode("SNAKE_OIL_PARAM") active_list = dataset.getActiveList("SNAKE_OIL_PARAM") for i in localized_idxs: active_list.addActiveIndex(i) obs = local_config.createObsdata("OBSSET_LOCA") obs.addNode("WOPR_OP1_72") ministep = local_config.createMinistep("MINISTEP_LOCA") ministep.attachDataset(dataset) ministep.attachObsset(obs) updatestep = local_config.getUpdatestep() updatestep.attachMinistep(ministep) # Run enseble smoother mask = BoolVector(initial_size=ert.getEnsembleSize(), default_value=True) model_config = ert.getModelConfig() path_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = None run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, path_fmt, jobname_fmt, subst_list, 0 ) es_update.smootherUpdate(run_context) conf = ert.ensembleConfig()["SNAKE_OIL_PARAM"] sim_node = EnkfNode(conf) target_node = EnkfNode(conf) node_id = NodeId(0, 0) sim_node.load(sim_fs, node_id) target_node.load(target_fs, node_id) sim_gen_kw = sim_node.asGenKw() target_gen_kw = target_node.asGenKw() # Test that the localized values has been updated for i in localized_idxs: self.assertNotEqual(sim_gen_kw[i], target_gen_kw[i]) # test that all the other values are left unchanged non_localized_idxs = ( x for x in range(len(sim_gen_kw)) if x not in localized_idxs ) for i in non_localized_idxs: self.assertEqual(sim_gen_kw[i], target_gen_kw[i])
def test_localization(setup_case, expected_target_gen_kw): """ Note that this is now a snapshot test, so there is no guarantee that the snapshots are correct, they are just documenting the current behavior. """ res_config = setup_case("local/snake_oil", "snake_oil.ert") ert = EnKFMain(res_config) es_update = ESUpdate(ert) fsm = ert.getEnkfFsManager() sim_fs = fsm.getFileSystem("default_0") target_fs = fsm.getFileSystem("target") # perform localization localized_idxs = (1, 2) local_config = ert.getLocalConfig() local_config.clear() obs = local_config.createObsdata("OBSSET_LOCA") obs.addNode("WOPR_OP1_72") ministep = local_config.createMinistep("MINISTEP_LOCA") ministep.addActiveData("SNAKE_OIL_PARAM") # replace dataset.addNode() active_list = ministep.getActiveList("SNAKE_OIL_PARAM") for i in localized_idxs: active_list.addActiveIndex(i) ministep.attachObsset(obs) updatestep = local_config.getUpdatestep() updatestep.attachMinistep(ministep) # Run enseble smoother mask = BoolVector(initial_size=ert.getEnsembleSize(), default_value=True) model_config = ert.getModelConfig() path_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = None run_context = ErtRunContext.ensemble_smoother(sim_fs, target_fs, mask, path_fmt, jobname_fmt, subst_list, 0) es_update.smootherUpdate(run_context) conf = ert.ensembleConfig()["SNAKE_OIL_PARAM"] sim_node = EnkfNode(conf) target_node = EnkfNode(conf) node_id = NodeId(0, 0) sim_node.load(sim_fs, node_id) target_node.load(target_fs, node_id) sim_gen_kw = list(sim_node.asGenKw()) target_gen_kw = list(target_node.asGenKw()) # Test that the localized values has been updated assert sim_gen_kw[1:3] != target_gen_kw[1:3] # test that all the other values are left unchanged assert sim_gen_kw[3:] == target_gen_kw[3:] assert sim_gen_kw[0] == target_gen_kw[0] assert target_gen_kw == pytest.approx(expected_target_gen_kw)
def init_data(main): fsm = main.getEnkfFsManager() init_fs = fsm.getFileSystem("init") grid = main.eclConfig().getGrid() # Model: bhp = poro * 1000 poro_mean = 0.15 poro_std = 0.10 bhp_std = 125 # Model: wct = poro * 4 wct_std = 0.30 bhp = [] wct = [] num_realisations = main.getEnsembleSize() # The path fields/poro{}.grdecl must be consistent with the INIT_FILES: argument in the # PORO configuration in the configuration file used for the testcase. os.mkdir("fields") random.seed(12345) for i in range(num_realisations): with open("fields/poro{}.grdecl".format(i), "w") as f: poro = random.gauss(poro_mean, poro_std) f.write("PORO") for i in range(grid.get_num_active()): if i % 10 == 0: f.write("\n") f.write("{:<7.5} ".format(poro)) f.write("\n/\n") bhp.append(poro * 1000 + random.gauss(0, bhp_std)) wct.append(poro * 4 + random.gauss(0, wct_std)) mask = BoolVector(initial_size=main.getEnsembleSize(), default_value=True) init_context = ErtRunContext.case_init(init_fs, mask) main.initRun(init_context) ens_config = main.ensembleConfig() bhp_config = ens_config["WBHP"] wct_config = ens_config["WWCT"] state_map = init_fs.getStateMap() for iens in range(main.getEnsembleSize()): bhp_node = EnkfNode(bhp_config) bhp_summary = bhp_node.as_summary() bhp_summary[1] = bhp[iens] wct_node = EnkfNode(wct_config) wct_summary = wct_node.as_summary() wct_summary[1] = wct[iens] node_id = NodeId(1, iens) bhp_node.save(init_fs, node_id) wct_node.save(init_fs, node_id) state_map[iens] = RealizationStateEnum.STATE_HAS_DATA return init_fs
def filterObsKeys(self, obs_keys, fs): active_mask = BoolVector(True, self.ert().getEnsembleSize()) ert_obs = self.ert().getObservations() result = [] for obs_key in obs_keys: obsVector = ert_obs[obs_key] if obsVector.hasData(active_mask, fs): result.append(obs_key) return result
def test_repr(self): primes = [2, 3, 5, 7, 11, 13, 17, 19] b = BoolVector() for i in primes: b[i] = True pfx = 'BoolVector(size = 20, content = "00110101000101000101")' self.assertEqual(pfx, repr(b)[:len(pfx)]) b[30] = True pfx = 'BoolVector(size = 31, content = "001101010...00000001")' self.assertEqual(pfx, repr(b)[:len(pfx)])
def realizationList(self, state_value): """ Will create a list of all realisations with state equal to state_value. @type state_value: RealizationStateEnum @rtype: ecl.util.IntVector """ mask = BoolVector(False, len(self)) self.selectMatching(mask, state_value) return BoolVector.createActiveList(mask)
def createMask(self, state_value): """ Will create a bool vector of all realisations with state equal to state_value. @type state_value: RealizationStateEnum @rtype: ecl.util.BoolVector """ mask = BoolVector(False, len(self)) self.selectMatching(mask, state_value) return mask
def test_create_active_list(self): vec = BoolVector(False, 10) vec[0] = True vec[3] = True vec[7] = True idxs = vec.createActiveList() self.assertTrue(len(idxs) == 3, "Should get 3 indices") self.assertEqual(idxs[0], 0) self.assertEqual(idxs[1], 3) self.assertEqual(idxs[2], 7)
def create_mask_from_failed_realizations(self): """ Creates a BoolVector mask representing the failed realizations :return: Type BoolVector """ completed = self._run_model.completed_realizations_mask initial = self._run_model.initial_realizations_mask inverted_mask = BoolVector(default_value=False) for (index, successful) in enumerate(completed): inverted_mask[index] = initial[index] and not successful return inverted_mask