def run_ensemble_evaluator(self, run_context: ErtRunContext,
ee_config: EvaluatorServerConfig) -> int:
if run_context.get_step():
self.ert().eclConfig().assert_restart()
ensemble = EnsembleBuilder.from_legacy(
run_context,
self.get_forward_model(),
self._queue_config,
self.ert().analysisConfig(),
self.ert().resConfig(),
).build()
self.ert().initRun(run_context)
totalOk = EnsembleEvaluator(
ensemble,
ee_config,
run_context.get_iter(),
ee_id=str(uuid.uuid1()).split("-", maxsplit=1)[0],
).run_and_get_successful_realizations()
for iens, run_arg in enumerate(run_context):
if run_context.is_active(iens):
if run_arg.run_status in (
RunStatusType.JOB_LOAD_FAILURE,
RunStatusType.JOB_RUN_FAILURE,
):
run_context.deactivate_realization(iens)
run_context.get_sim_fs().fsync()
return totalOk
def from_legacy(
run_context: ErtRunContext,
forward_model: ForwardModel,
queue_config: QueueConfig,
analysis_config: AnalysisConfig,
res_config: ResConfig,
) -> "_EnsembleBuilder":
builder = _EnsembleBuilder().set_legacy_dependencies(
queue_config,
analysis_config,
)
num_cpu = res_config.queue_config.num_cpu
if num_cpu == 0:
num_cpu = res_config.ecl_config.num_cpu
for iens, run_arg in enumerate(run_context):
active = run_context.is_active(iens)
real = _RealizationBuilder().set_iens(iens).active(active)
step = _StepBuilder().set_id("0").set_dummy_io().set_name("legacy step")
if active:
real.active(True).add_step(step)
for index in range(0, len(forward_model)):
ext_job = forward_model.iget_job(index)
step.add_job(
_LegacyJobBuilder()
.set_id(str(index))
.set_name(ext_job.name())
.set_ext_job(ext_job)
)
step.set_max_runtime(
analysis_config.get_max_runtime()
).set_callback_arguments((run_arg, res_config)).set_done_callback(
EnKFState.forward_model_ok_callback
).set_exit_callback(
EnKFState.forward_model_exit_callback
).set_num_cpu(
num_cpu
).set_run_path(
run_arg.runpath
).set_job_script(
res_config.queue_config.job_script
).set_job_name(
run_arg.job_name
).set_run_arg(
run_arg
)
builder.add_realization(real)
return builder
def run_ensemble_evaluator(self, run_context: ErtRunContext,
ee_config: EvaluatorServerConfig) -> int:
if run_context.get_step():
self.ert().eclConfig().assert_restart()
iactive = run_context.get_mask()
run_context.get_sim_fs().getStateMap().deselectMatching(
iactive,
RealizationStateEnum.STATE_LOAD_FAILURE
| RealizationStateEnum.STATE_PARENT_FAILURE,
)
ensemble = create_ensemble_builder_from_legacy(
run_context,
self.get_forward_model(),
self._queue_config,
self.ert().analysisConfig(),
self.ert().resConfig(),
).build()
self.ert().initRun(run_context)
totalOk = EnsembleEvaluator(
ensemble,
ee_config,
run_context.get_iter(),
ee_id=str(uuid.uuid1()).split("-")[0],
).run_and_get_successful_realizations()
for i in range(len(run_context)):
if run_context.is_active(i):
run_arg = run_context[i]
if (run_arg.run_status == RunStatusType.JOB_LOAD_FAILURE or
run_arg.run_status == RunStatusType.JOB_RUN_FAILURE):
run_context.deactivate_realization(i)
run_context.get_sim_fs().fsync()
return totalOk
def _is_iens_active(iens: int, run_context: ErtRunContext) -> bool:
"""Return whether or not the iens is active."""
try:
return run_context.is_active(iens)
except AttributeError:
return False