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_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 _verify_runpath_rendering(self, itr):
with ErtTestContext(
"add_all_runpath_dump", model_config=self.config_path
) as ctx:
res = ctx.getErt()
fs_manager = res.getEnkfFsManager()
sim_fs = fs_manager.getFileSystem("sim_fs")
num_realizations = 25
mask = BoolVector(initial_size=num_realizations, default_value=True)
mask[13] = False
runpath_fmt = "simulations/<GEO_ID>/realisation-%d/iter-%d/magic-real-<IENS>/magic-iter-<ITER>"
jobname_fmt = "SNAKE_OIL_%d"
subst_list = res.resConfig().subst_config.subst_list
run_context = ErtRunContext.ensemble_experiment(
sim_fs, mask, PathFormat(runpath_fmt), jobname_fmt, subst_list, itr
)
res.initRun(run_context)
for i, run_arg in enumerate(run_context):
if mask[i]:
run_arg.geo_id = 10 * i
res.createRunpath(run_context)
for i, run_arg in enumerate(run_context):
if not mask[i]:
continue
self.assertTrue(os.path.isdir("simulations/%d" % run_arg.geo_id))
runpath_list_path = ".ert_runpath_list"
self.assertTrue(os.path.isfile(runpath_list_path))
exp_runpaths = [
render_dynamic_values(runpath_fmt, itr, iens, run_arg.geo_id)
% (iens, itr)
for iens, run_arg in enumerate(run_context)
if mask[iens]
]
exp_runpaths = map(os.path.realpath, exp_runpaths)
with open(runpath_list_path, "r") as f:
dumped_runpaths = list(zip(*[line.split() for line in f.readlines()]))[
1
]
self.assertEqual(list(exp_runpaths), list(dumped_runpaths))
def create_context(self, arguments):
fs_manager = self.ert().getEnkfFsManager()
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(
result_fs, mask, runpath_fmt, subst_list, itr)
return 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) -> ErtRunContext:
fs_manager = self.ert().getEnkfFsManager()
result_fs = fs_manager.getCurrentFileSystem()
model_config = self.ert().getModelConfig()
runpath_fmt = model_config.getRunpathFormat()
jobname_fmt = model_config.getJobnameFormat()
subst_list = self.ert().getDataKW()
itr = self._simulation_arguments.get("iter_num", 0)
mask = self._simulation_arguments["active_realizations"]
run_context = ErtRunContext.ensemble_experiment(
result_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 _experiment_run(ert):
source_fs, _ = setup_fs(ert)
model_config = ert.getModelConfig()
subst_list = ert.getDataKW()
mask = BoolVector(default_value=True, initial_size=ert.getEnsembleSize())
run_context = ErtRunContext.ensemble_experiment(
sim_fs=source_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, run_context, sim_runner)
def create_context(self, arguments):
fs_manager = self.ert().getEnkfFsManager()
result_fs = fs_manager.getCurrentFileSystem()
model_config = self.ert().getModelConfig()
runpath_fmt = model_config.getRunpathFormat()
jobname_fmt = model_config.getJobnameFormat()
subst_list = self.ert().getDataKW()
itr = arguments.get("iter_num", 0)
mask = arguments["active_realizations"]
run_context = ErtRunContext.ensemble_experiment(
result_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr)
# Deleting a run_context removes the possibility to retrospectively
# determine detailed progress. Thus, before deletion, the detailed
# progress is stored.
self.updateDetailedProgress()
self._run_context = run_context
self._last_run_iteration = run_context.get_iter()
return run_context
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()
model_config = enkf_main.getModelConfig()
runpath_fmt = model_config.getRunpathFormat()
jobname_fmt = model_config.getJobnameFormat()
subst_list = enkf_main.getDataKW()
run_context = ErtRunContext.ensemble_experiment(
result_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_assert_export(use_tmpdir):
# Write a minimal config file with env
with open("config_file.ert", "w") as fout:
fout.write(
dedent(
"""
NUM_REALIZATIONS 1
JOBNAME a_name_%d
RUNPATH_FILE directory/test_runpath_list.txt
"""
)
)
res_config = ResConfig("config_file.ert")
ert = EnKFMain(res_config)
runpath_list = ert.getRunpathList()
assert not os.path.isfile(runpath_list.getExportFile())
fs_manager = ert.getEnkfFsManager()
model_config = ert.getModelConfig()
run_context = ErtRunContext.ensemble_experiment(
fs_manager.getCurrentFileSystem(),
[True],
model_config.getRunpathFormat(),
model_config.getJobnameFormat(),
ert.getDataKW(),
0,
)
ert.getEnkfSimulationRunner().createRunPath(run_context)
assert os.path.isfile(runpath_list.getExportFile())
assert "test_runpath_list.txt" == os.path.basename(runpath_list.getExportFile())
assert (
Path(runpath_list.getExportFile()).read_text("utf-8")
== f"000 {os.getcwd()}/simulations/realization0 a_name_0 000\n"
)
def test_run(self):
ens_size = 2
config_file = self.createTestPath(
"local/config/simulation_batch/config.ert")
with ErtTestContext("simulation_batch",
model_config=config_file) as ctx:
ert = ctx.getErt()
ens_config = ert.ensembleConfig()
# Observe that a significant amount of hardcoding
# regarding the GEN_DATA and EXT_PARAM nodes is assumed
# between this test, the config file and the forward model.
# Add control nodes
order_control = EnkfConfigNode.create_ext_param(
"WELL_ORDER", ["W1", "W2", "W3"])
injection_control = EnkfConfigNode.create_ext_param(
"WELL_INJECTION", ["W1", "W4"])
ens_config.addNode(order_control)
ens_config.addNode(injection_control)
# Add result nodes
order_result = EnkfConfigNode.create_gen_data("ORDER", "order_%d")
injection_result = EnkfConfigNode.create_gen_data(
"INJECTION", "injection_%d")
ens_config.addNode(order_result)
ens_config.addNode(injection_result)
order_node = EnkfNode(order_control)
order_node_ext = order_node.as_ext_param()
injection_node = EnkfNode(injection_control)
injection_node_ext = injection_node.as_ext_param()
fs_manager = ert.getEnkfFsManager()
sim_fs = fs_manager.getFileSystem("sim_fs")
state_map = sim_fs.getStateMap()
batch_size = ens_size + 2
for iens in range(batch_size):
node_id = NodeId(0, iens)
order_node_ext["W1"] = iens
order_node_ext["W2"] = iens * 10
order_node_ext["W3"] = iens * 100
order_node.save(sim_fs, node_id)
injection_node_ext["W1"] = iens + 1
injection_node_ext["W4"] = 3 * (iens + 1)
injection_node.save(sim_fs, node_id)
state_map[iens] = RealizationStateEnum.STATE_INITIALIZED
mask = BoolVector(default_value=True, initial_size=batch_size)
model_config = ert.getModelConfig()
runpath_fmt = model_config.getRunpathFormat()
jobname_fmt = model_config.getJobnameFormat()
subst_list = ert.getDataKW()
itr = 0
run_context = ErtRunContext.ensemble_experiment(
sim_fs, mask, runpath_fmt, jobname_fmt, subst_list, itr)
ert.getEnkfSimulationRunner().createRunPath(run_context)
job_queue = ert.get_queue_config().create_job_queue()
ert.createRunpath(run_context)
num = ert.getEnkfSimulationRunner().runEnsembleExperiment(
job_queue, run_context)
self.assertEqual(num, batch_size)
order_result = EnkfNode(ens_config["ORDER"])
injection_result = EnkfNode(ens_config["INJECTION"])
for iens in range(batch_size):
node_id = NodeId(0, iens)
order_result.load(sim_fs, node_id)
data = order_result.asGenData()
order_node.load(sim_fs, node_id)
self.assertEqual(order_node_ext["W1"], data[0])
self.assertEqual(order_node_ext["W2"], data[1])
self.assertEqual(order_node_ext["W3"], data[2])
