def _runAndPostProcess( self, run_context: ErtRunContext, evaluator_server_config: EvaluatorServerConfig, update_id: Optional[str] = None, ) -> str: phase_msg = "Running iteration %d of %d simulation iterations..." % ( run_context.get_iter(), self.phaseCount() - 1, ) self.setPhase(run_context.get_iter(), phase_msg, indeterminate=False) self.setPhaseName("Pre processing...", indeterminate=True) self.ert().getEnkfSimulationRunner().createRunPath(run_context) EnkfSimulationRunner.runWorkflows(HookRuntime.PRE_SIMULATION, ert=self.ert()) # create ensemble ensemble_id = self._post_ensemble_data(update_id=update_id) self.setPhaseName("Running forecast...", indeterminate=False) num_successful_realizations = self.run_ensemble_evaluator( run_context, evaluator_server_config ) self.checkHaveSufficientRealizations(num_successful_realizations) self.setPhaseName("Post processing...", indeterminate=True) EnkfSimulationRunner.runWorkflows(HookRuntime.POST_SIMULATION, ert=self.ert()) self._post_ensemble_results(ensemble_id) return ensemble_id
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 run(self): target = self._run_widget.target_case() source = self._run_widget.source_case() ert = ERT.ert fs_manager = ert.getEnkfFsManager() es_update = ESUpdate(ert) target_fs = fs_manager.getFileSystem(target) source_fs = fs_manager.getFileSystem(source) run_context = ErtRunContext.ensemble_smoother_update( source_fs, target_fs, ) success = es_update.smootherUpdate(run_context) if not success: msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setWindowTitle("Run Analysis") msg.setText("Unable to run analysis for case '%s'." % source) msg.setStandardButtons(QMessageBox.Ok) msg.exec_() return ERT.ertChanged.emit() self._dialog.accept()
def test_assert_symlink_deleted(setup_case): res_config = setup_case("local/snake_oil_field", "snake_oil.ert") ert = EnKFMain(res_config) runpath_list = ert.getRunpathList() runner = ert.getEnkfSimulationRunner() # create directory structure model_config = ert.getModelConfig() run_context = ErtRunContext.ensemble_experiment( ert.getEnkfFsManager().getCurrentFileSystem(), [True], model_config.getRunpathFormat(), model_config.getJobnameFormat(), ert.getDataKW(), 0, ) 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 assert not os.path.islink(linkpath)
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 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 create_context( self, prior_context: Optional[ErtRunContext] = None) -> ErtRunContext: model_config = self.ert().getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = self.ert().getDataKW() fs_manager = self.ert().getEnkfFsManager() if prior_context is None: sim_fs = fs_manager.getCurrentFileSystem() target_fs = fs_manager.getFileSystem( self._simulation_arguments["target_case"]) itr = 0 mask = self._simulation_arguments["active_realizations"] else: itr = 1 sim_fs = prior_context.get_target_fs() target_fs = None mask = sim_fs.getStateMap().createMask( RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED) run_context = ErtRunContext.ensemble_smoother(sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() return run_context
def create_context(self, arguments, prior_context=None): model_config = self.ert().getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = self.ert().getDataKW() fs_manager = self.ert().getEnkfFsManager() if prior_context is None: sim_fs = fs_manager.getCurrentFileSystem() target_fs = fs_manager.getFileSystem(arguments["target_case"]) itr = 0 mask = arguments["active_realizations"] else: itr = 1 sim_fs = prior_context.get_target_fs() target_fs = None state = RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED mask = sim_fs.getStateMap().createMask(state) # Deleting a run_context removes the possibility to retrospectively # determine detailed progress. Thus, before deletion, the detailed # progress is stored. self.updateDetailedProgress() run_context = ErtRunContext.ensemble_smoother(sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() 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() 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, 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 create_context( self, itr: int, prior_context: Optional[ErtRunContext] = None, rerun: bool = False, ) -> ErtRunContext: model_config = self.ert().getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = self.ert().getDataKW() target_case_format = self._simulation_arguments["target_case"] sim_fs = self.createTargetCaseFileSystem(itr, target_case_format) if prior_context is None: mask = self._simulation_arguments["active_realizations"] else: state: RealizationStateEnum = ( RealizationStateEnum.STATE_HAS_DATA # type: ignore | RealizationStateEnum.STATE_INITIALIZED ) mask = sim_fs.getStateMap().createMask(state) if rerun: target_fs = None else: target_fs = self.createTargetCaseFileSystem(itr + 1, target_case_format) run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr ) self._run_context = run_context self._last_run_iteration = run_context.get_iter() self.ert().getEnkfFsManager().switchFileSystem(sim_fs) return run_context
def update(self, run_context: ErtRunContext, weight: float, ensemble_id: str) -> str: next_iteration = run_context.get_iter() + 1 phase_string = "Analyzing iteration: %d with weight %f" % ( next_iteration, weight, ) self.setPhase(self.currentPhase() + 1, phase_string, indeterminate=True) es_update = self.ert().getESUpdate() es_update.setGlobalStdScaling(weight) try: es_update.smootherUpdate(run_context) except ErtAnalysisError as e: raise ErtRunError( "Analysis of simulation failed for iteration:" f"{next_iteration}. The following error occured {e}") from e # Push update data to new storage analysis_module_name = self.ert().analysisConfig().activeModuleName() update_id = self._post_update_data(parent_ensemble_id=ensemble_id, algorithm=analysis_module_name) return update_id
def test_assert_export(self): with ErtTestContext( "create_runpath1", self.createTestPath( "local/snake_oil_no_data/snake_oil.ert")) as tc: ert = tc.getErt() runpath_list = ert.getRunpathList() self.assertFalse(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=100, default_value=True) runpath_fmt = ert.getModelConfig().getRunpathFormat() subst_list = SubstitutionList() itr = 0 run_context1 = ErtRunContext(EnkfRunType.INIT_ONLY, init_fs, None, None, mask, runpath_fmt, subst_list, itr) runner.createRunPath(run_context1) self.assertTrue(path.isfile(runpath_list.getExportFile())) self.assertEqual("test_runpath_list.txt", path.basename(runpath_list.getExportFile()))
def test_update_code1(self): with ErtTestContext("row_scaling", self.config_file) as tc: main = tc.getErt() local_config = main.getLocalConfig() local_config.clear() obs = local_config.createObsdata("OBSSET_LOCAL") obs.addNode("WBHP0") obs.addNode("WWCT0") ministep = local_config.createMinistep("MINISTEP_LOCAL") ministep.addActiveData("PORO") ministep.attachObsset(obs) updatestep = local_config.getUpdatestep() updatestep.attachMinistep(ministep) row_scaling = ministep.row_scaling("PORO") ens_config = main.ensembleConfig() poro_config = ens_config["PORO"] field_config = poro_config.getFieldModelConfig() # ------------------------------------------------------------------------------------- grid = main.eclConfig().getGrid() obs_pos = grid.get_xyz(ijk=(5, 5, 1)) length_scale = (2, 1, 0.50) row_scaling.assign(field_config.get_data_size(), GaussianDecay(obs_pos, length_scale, grid)) # ------------------------------------------------------------------------------------- init_fs = init_data(main) target_fs = main.getEnkfFsManager().getFileSystem("target") es_update = ESUpdate(main) run_context = ErtRunContext.ensemble_smoother_update( init_fs, target_fs) es_update.smootherUpdate(run_context)
def create_context(self, arguments, itr, prior_context = None, update = True): target_case_format = arguments["target_case"] model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) jobname_fmt = model_config.getJobnameFormat( ) subst_list = self.ert().getDataKW( ) fs_manager = self.ert().getEnkfFsManager() sim_fs = fs_manager.getFileSystem(target_case_format % itr) if update: target_fs = fs_manager.getFileSystem(target_case_format % (itr + 1)) else: target_fs = None if prior_context is None: mask = arguments["active_realizations"] else: state = RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED mask = sim_fs.getStateMap().createMask(state) # Make sure to only run the realizations which was passed in as argument for index, run_realization in enumerate(self.initial_realizations_mask): mask[index] = mask[index] and run_realization run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() return run_context
def create_context(self, arguments, itr, prior_context=None, rerun=False): model_config = self.ert().getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = self.ert().getDataKW() fs_manager = self.ert().getEnkfFsManager() target_case_format = arguments["target_case"] if prior_context is None: mask = arguments["active_realizations"] else: mask = prior_context.get_mask() sim_fs = self.createTargetCaseFileSystem(itr, target_case_format) if rerun: target_fs = None else: target_fs = self.createTargetCaseFileSystem( itr + 1, target_case_format) run_context = ErtRunContext.ensemble_smoother(sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() return run_context
def create_context(self, arguments, itr, prior_context=None, rerun=False): model_config = self.ert().getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = self.ert().getDataKW() target_case_format = arguments["target_case"] sim_fs = self.createTargetCaseFileSystem(itr, target_case_format) if prior_context is None: mask = arguments["active_realizations"] else: state = (RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED) mask = sim_fs.getStateMap().createMask(state) if rerun: target_fs = None else: target_fs = self.createTargetCaseFileSystem( itr + 1, target_case_format) # Deleting a run_context removes the possibility to retrospectively # determine detailed progress. Thus, before deletion, the detailed # progress is stored. self.updateDetailedProgress() run_context = ErtRunContext.ensemble_smoother(sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() self.ert().getEnkfFsManager().switchFileSystem(sim_fs) return run_context
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 create_context(self, arguments, itr, prior_context=None, update=True): target_case_format = arguments["target_case"] model_config = self.ert().getModelConfig() runpath_fmt = model_config.getRunpathFormat() jobname_fmt = model_config.getJobnameFormat() subst_list = self.ert().getDataKW() fs_manager = self.ert().getEnkfFsManager() sim_fs = fs_manager.getFileSystem(target_case_format % itr) if update: target_fs = fs_manager.getFileSystem(target_case_format % (itr + 1)) else: target_fs = None if prior_context is None: mask = arguments["active_realizations"] else: state = RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED mask = sim_fs.getStateMap().createMask(state) # Make sure to only run the realizations which was passed in as argument for index, run_realization in enumerate( self.initial_realizations_mask): mask[index] = mask[index] and run_realization run_context = ErtRunContext.ensemble_smoother(sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() 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( ) 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, 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 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 _run_ministep(ert, obs_group, data_parameters, prior_name, target_name, output_path): local_config = ert.getLocalConfig() # Reset internal local config structure, in order to make your own local_config.clear() # A ministep is used to link betwen data and observations. # Make more ministeps to condition different groups together ministep = local_config.createMinistep("MINISTEP") # Add all dataset to localize data_all = local_config.createDataset("DATASET") for data in data_parameters: data_all.addNode(data) # Add all obs to be used in this updating scheme obsdata = local_config.createObsdata("OBS") for obs in obs_group: obsdata.addNode(obs) # Attach the created dataset and obsset to the ministep ministep.attachDataset(data_all) ministep.attachObsset(obsdata) # Then attach the ministep to the update step local_config.getUpdatestep().attachMinistep(ministep) # Perform update analysis ert.analysisConfig().set_log_path(output_path) run_context = ErtRunContext.ensemble_smoother_update( ert.getEnkfFsManager().getFileSystem(prior_name), ert.getEnkfFsManager().getFileSystem(target_name), ) ESUpdate(ert).smootherUpdate(run_context)
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 = [True] * main.getEnsembleSize() 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 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 ensemble smoother mask = [True] * ert.getEnsembleSize() 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 _ensemble_smoother_run(ert, target_case): source_fs, target_fs = setup_fs(ert, target_case) model_config = ert.getModelConfig() subst_list = ert.getDataKW() mask = BoolVector(default_value=True, initial_size=ert.getEnsembleSize()) prior_context = ErtRunContext.ensemble_smoother( sim_fs=source_fs, target_fs=target_fs, mask=mask, path_fmt=model_config.getRunpathFormat(), jobname_fmt=model_config.getJobnameFormat(), subst_list=subst_list, itr=0) sim_runner = ert.getEnkfSimulationRunner() _run_ensemble_experiment(ert, prior_context, sim_runner) sim_runner.runWorkflows(HookRuntime.PRE_UPDATE) es_update = ESUpdate(ert) success = es_update.smootherUpdate(prior_context) if not success: raise AssertionError("Analysis of simulation failed!") sim_runner.runWorkflows(HookRuntime.POST_UPDATE) ert.getEnkfFsManager().switchFileSystem(prior_context.get_target_fs()) sim_fs = prior_context.get_target_fs() state = RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED mask = sim_fs.getStateMap().createMask(state) rerun_context = ErtRunContext.ensemble_smoother( sim_fs=sim_fs, target_fs=None, mask=mask, path_fmt=model_config.getRunpathFormat(), jobname_fmt=model_config.getJobnameFormat(), subst_list=subst_list, itr=1) _run_ensemble_experiment(ert, rerun_context, sim_runner)
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 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 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 create_context(self, arguments): fs_manager = self.ert().getEnkfFsManager() init_fs = fs_manager.getCurrentFileSystem( ) result_fs = fs_manager.getCurrentFileSystem( ) model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) subst_list = self.ert().getDataKW( ) itr = 0 mask = arguments["active_realizations"] run_context = ErtRunContext.ensemble_experiment( init_fs, result_fs, mask, runpath_fmt, subst_list, itr) return run_context
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) runpath_fmt = PathFormat("path/to/sim%d") subst_list = SubstitutionList() itr = 0 run_context1 = ErtRunContext(EnkfRunType.ENSEMBLE_EXPERIMENT, sim_fs, target_fs, mask, runpath_fmt, subst_list, itr) run_id1 = run_context1.get_id() run_arg0 = run_context1[0] self.assertEqual(run_id1, run_arg0.get_run_id()) run_context2 = ErtRunContext(EnkfRunType.ENSEMBLE_EXPERIMENT, sim_fs, target_fs, mask, runpath_fmt, subst_list, itr) run_id2 = run_context2.get_id() self.assertFalse(run_id1 == run_id2)
def test_update_workflow(self): with ErtTestContext("row_scaling", self.config_file) as tc: main = tc.getErt() workflow_list = main.getWorkflowList() workflow = workflow_list["ROW_SCALING_WORKFLOW1"] self.assertTrue(workflow.run(main)) init_fs = init_data(main) target_fs = main.getEnkfFsManager().getFileSystem("target") es_update = ESUpdate(main) run_context = ErtRunContext.ensemble_smoother_update(init_fs, target_fs) es_update.smootherUpdate(run_context)
def create_context(self, arguments): fs_manager = self.ert().getEnkfFsManager() init_fs = fs_manager.getCurrentFileSystem( ) result_fs = fs_manager.getCurrentFileSystem( ) model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) subst_list = self.ert().getDataKW( ) itr = 0 mask = BoolVector( default_value = False ) mask[0] = True run_context = ErtRunContext.ensemble_experiment( init_fs, result_fs, mask, runpath_fmt, subst_list, itr) return run_context
def create_context(self, arguments, prior_context = None): model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) subst_list = self.ert().getDataKW( ) fs_manager = self.ert().getEnkfFsManager() if prior_context is None: sim_fs = fs_manager.getCurrentFileSystem( ) target_fs = fs_manager.getFileSystem("smoother-update") itr = 0 mask = arguments["active_realizations"] else: itr = 1 mask = prior_context.get_mask( ) sim_fs = prior_context.get_target_fs( ) target_fs = None run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, runpath_fmt, subst_list, itr) return run_context
def create_context(self, arguments, itr, prior_context = None, rerun = False): model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) subst_list = self.ert().getDataKW( ) fs_manager = self.ert().getEnkfFsManager() target_case_format = arguments["target_case"] if prior_context is None: mask = arguments["active_realizations"] else: mask = prior_context.get_mask( ) sim_fs = self.createTargetCaseFileSystem(itr, target_case_format) if rerun: target_fs = None else: target_fs = self.createTargetCaseFileSystem(itr + 1 , target_case_format) run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, runpath_fmt, subst_list, itr) return run_context
def create_context(self, arguments, itr, prior_context = None, update = True): target_case_format = arguments["target_case"] model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) jobname_fmt = model_config.getJobnameFormat( ) subst_list = self.ert().getDataKW( ) fs_manager = self.ert().getEnkfFsManager() sim_fs = fs_manager.getFileSystem(target_case_format % itr) if update: target_fs = fs_manager.getFileSystem(target_case_format % (itr + 1)) else: target_fs = None if prior_context is None: mask = arguments["active_realizations"] else: mask = prior_context.get_mask( ) run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) return run_context
def create_context(self, arguments, prior_context = None): model_config = self.ert().getModelConfig( ) runpath_fmt = model_config.getRunpathFormat( ) jobname_fmt = model_config.getJobnameFormat( ) subst_list = self.ert().getDataKW( ) fs_manager = self.ert().getEnkfFsManager() if prior_context is None: sim_fs = fs_manager.getCurrentFileSystem( ) target_fs = fs_manager.getFileSystem(arguments["target_case"]) itr = 0 mask = arguments["active_realizations"] else: itr = 1 sim_fs = prior_context.get_target_fs( ) target_fs = None state = RealizationStateEnum.STATE_HAS_DATA | RealizationStateEnum.STATE_INITIALIZED mask = sim_fs.getStateMap().createMask(state) run_context = ErtRunContext.ensemble_smoother( sim_fs, target_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr) self._run_context = run_context self._last_run_iteration = run_context.get_iter() return run_context
def run(self): target = self._run_widget.target_case() source = self._run_widget.source_case() ert = ERT.ert fs_manager = ert.getEnkfFsManager() es_update = ESUpdate(ert) target_fs = fs_manager.getFileSystem(target) source_fs = fs_manager.getFileSystem(source) run_context = ErtRunContext.ensemble_smoother_update( source_fs, target_fs, ) success = es_update.smootherUpdate( run_context ) if not success: msg = QMessageBox() msg.setIcon(QMessageBox.Warning) msg.setWindowTitle("Run Analysis") msg.setText("Unable to run analysis for case '%s'." % source) msg.setStandardButtons(QMessageBox.Ok) msg.exec_() return ERT.ertChanged.emit() self._dialog.accept()