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,
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 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)
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 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 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, 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()
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 _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 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 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 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 create_context(self,
arguments,
itr,
initialize_mask_from_arguments=True,
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()
source_case_name = target_case_format % itr
if itr > 0 and not fs_manager.caseExists(source_case_name):
raise ErtRunError(
"Source case {} for iteration {} does not exists. "
"If you are attempting to restart ESMDA from a iteration other than 0, "
"make sure the target case format is the same as for the original run! "
"(Current target case format: {})".format(
source_case_name, itr, target_case_format))
sim_fs = fs_manager.getFileSystem(source_case_name)
if update:
target_fs = fs_manager.getFileSystem(target_case_format %
(itr + 1))
else:
target_fs = None
if initialize_mask_from_arguments:
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
# 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 create_context(
self,
itr: int,
initialize_mask_from_arguments: bool = True,
update: bool = True,
) -> ErtRunContext:
target_case_format = self._simulation_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()
source_case_name = target_case_format % itr
if itr > 0 and not fs_manager.caseExists(source_case_name):
raise ErtRunError(
"Source case {} for iteration {} does not exists. "
"If you are attempting to restart ESMDA from a iteration other than 0, "
"make sure the target case format is the same as for the original run! "
"(Current target case format: {})".format(
source_case_name, itr, target_case_format))
sim_fs = fs_manager.getFileSystem(source_case_name)
if update:
target_fs = fs_manager.getFileSystem(target_case_format %
(itr + 1))
else:
target_fs = None
if initialize_mask_from_arguments:
mask = self._simulation_arguments["active_realizations"]
else:
mask = sim_fs.getStateMap().createMask(
RealizationStateEnum.STATE_HAS_DATA
| RealizationStateEnum.STATE_INITIALIZED)
# Make sure to only run the realizations which was passed in as argument
for idx, (valid_state, run_realization) in enumerate(
zip(mask, self._initial_realizations_mask)):
mask[idx] = valid_state 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()
self.ert().getEnkfFsManager().switchFileSystem(sim_fs)
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, 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, 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)
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 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()
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, subst_list,
itr)
return run_context
def _create_runpath(enkf_main: EnKFMain) -> ErtRunContext:
"""
Instantiate an ERT runpath. This will create the parameter coefficients.
"""
result_fs = enkf_main.getEnkfFsManager().getCurrentFileSystem()
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,
None,
BoolVector(default_value=True, initial_size=1),
runpath_fmt,
jobname_fmt,
subst_list,
0,
)
enkf_main.getEnkfSimulationRunner().createRunPath(run_context)
return run_context
