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 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 test_validate_no_realizations(test_data_root): """ Ensamble has not run """ test_data_dir = os.path.join(test_data_root, "poly_normal") shutil.copytree(test_data_dir, "test_data") os.chdir(os.path.join("test_data")) res_config = ResConfig("poly.ert") ert = EnKFMain(res_config) observations = ert.getObservations() result = keys_with_data( observations, ["POLY_OBS"], ert.getEnsembleSize(), ert.getEnkfFsManager().getCurrentFileSystem(), ) assert result == []
def test_validate_failed_realizations(test_data_root): """ Config has several failed realisations """ test_data_dir = os.path.join(test_data_root, "failed_runs_in_storage") shutil.copytree(test_data_dir, "test_data") os.chdir(os.path.join("test_data")) res_config = ResConfig("mini_fail_config") ert = EnKFMain(res_config) observations = ert.getObservations() result = keys_with_data( observations, ["GEN_PERLIN_1"], ert.getEnsembleSize(), ert.getEnkfFsManager().getCurrentFileSystem(), ) assert result == ["GEN_PERLIN_1"]
def initializeCurrentCaseFromExisting( source_case: str, target_case: str, source_report_step: int, parameters: List[str], members: List[str], ert: EnKFMain, ): if ( caseExists(source_case, LibresFacade(ert)) and ert.getEnkfFsManager().isCaseInitialized(source_case) and caseExists(target_case, LibresFacade(ert)) ): member_mask = [False] * ert.getEnsembleSize() for member in members: member_mask[int(member)] = True ert.getEnkfFsManager().customInitializeCurrentFromExistingCase( source_case, source_report_step, member_mask, parameters )
#!/usr/bin/env python import sys import time from res.enkf import EnKFMain, RunArg, NodeId, ResConfig from res.enkf.data import EnkfNode from ert.job_queue import JobQueueManager res_config = ResConfig( sys.argv[1] ) ert = EnKFMain( res_config ) fs_manager = ert.getEnkfFsManager( ) fs = fs_manager.getCurrentFileSystem( ) # Initialize the realisations. for iens in range( ert.getEnsembleSize()): realisation = ert.getRealisation( iens ) realisation.initialize( fs ) # Fetch out the job_queue from the SiteConfig object. In addition we # create a JobQueueManager objects which wraps the queue. The purpose # of this manager object is to let the queue run nonblocking in the # background. site_config = ert.siteConfig( ) queue_manager = JobQueueManager( site_config.getJobQueue( ) ) queue_manager.startQueue( ert.getEnsembleSize( ) , verbose = False ) # Create list of RunArg instances which hold metadata for one running # realisation, create the directory where the simulation should run # and submit the simulation.
#!/usr/bin/env python import sys import time from res.enkf import EnKFMain, RunArg, NodeId, ResConfig from res.enkf.data import EnkfNode from ert.job_queue import JobQueueManager res_config = ResConfig(sys.argv[1]) ert = EnKFMain(res_config) fs_manager = ert.getEnkfFsManager() fs = fs_manager.getCurrentFileSystem() # Initialize the realisations. for iens in range(ert.getEnsembleSize()): realisation = ert.getRealisation(iens) realisation.initialize(fs) # Fetch out the job_queue from the SiteConfig object. In addition we # create a JobQueueManager objects which wraps the queue. The purpose # of this manager object is to let the queue run nonblocking in the # background. site_config = ert.siteConfig() queue_manager = JobQueueManager(site_config.getJobQueue()) queue_manager.startQueue(ert.getEnsembleSize(), verbose=False) # Create list of RunArg instances which hold metadata for one running # realisation, create the directory where the simulation should run # and submit the simulation. path_fmt = "/tmp/run%d" arg_list = [ RunArg.createEnsembleExperimentRunArg(fs, iens, path_fmt % iens)
#!/usr/bin/env python import sys import time from res.enkf import EnKFMain, ResConfig from res.enkf.enums import ErtImplType # This will instantiate the EnkFMain object and create a handle to # "everything" ert related for this instance. res_config = ResConfig(sys.argv[1]) ert = EnKFMain(res_config) # Ask the EnKFMain instance how many realisations it has. Observe that # the answer to this question is just the value of the # NUM_REALISATIONS setting in the configuration file. print("This instance has %d realisations" % ert.getEnsembleSize()) # Get the ensemble configuration object, and ask for all GEN_KW keys: ens_config = ert.ensembleConfig() for key in ens_config.getKeylistFromImplType(ErtImplType.GEN_KW): config_node = ens_config[key] # "Downcast" to GEN_KW configuration. gen_kw_config = config_node.getModelConfig() print("%s : %s" % (key, gen_kw_config.getKeyWords()))
#!/usr/bin/env python import sys import time from res.enkf import EnKFMain, ResConfig from res.enkf.enums import ErtImplType # This will instantiate the EnkFMain object and create a handle to # "everything" ert related for this instance. res_config = ResConfig( sys.argv[1] ) ert = EnKFMain( res_config ) # Ask the EnKFMain instance how many realisations it has. Observe that # the answer to this question is just the value of the # NUM_REALISATIONS setting in the configuration file. print("This instance has %d realisations" % ert.getEnsembleSize()) # Get the ensemble configuration object, and ask for all GEN_KW keys: ens_config = ert.ensembleConfig( ) for key in ens_config.getKeylistFromImplType(ErtImplType.GEN_KW): config_node = ens_config[key] # "Downcast" to GEN_KW configuration. gen_kw_config = config_node.getModelConfig( ) print("%s : %s" % (key , gen_kw_config.getKeyWords( )))