def main(argv):
app = QApplication(argv) #Early so that QT is initialized before other imports
app.setWindowIcon(resourceIcon("application/window_icon_cutout"))
if len(argv) == 1:
sys.stderr.write("Missing configuration file")
sys.exit(1)
config_file = argv[1]
strict = True
if not os.path.exists(config_file):
print("Can not run without a configuration file.")
sys.exit(1)
if os.path.isdir(config_file):
print("The specified configuration file is a directory!")
sys.exit(1)
splash = ErtSplash()
splash.version = "Version %s" % Version.getVersion()
splash.timestamp = Version.getBuildTime()
splash.show()
splash.repaint()
now = time.time()
res_config = ResConfig(config_file)
ert = EnKFMain(res_config, strict=strict, verbose=False)
ert_gui.configureErtNotifier(ert, config_file)
window = PlotWindow(ert, None)
sleep_time = 2 - (time.time() - now)
if sleep_time > 0:
time.sleep(sleep_time)
window.show()
splash.finish(window)
window.activateWindow()
window.raise_()
finished_code = app.exec_()
ert.free()
sys.exit(finished_code)
def api(tmpdir, source_root):
with tmpdir.as_cwd():
test_data_root = source_root / "test-data" / "local"
test_data_dir = os.path.join(test_data_root, "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir("test_data")
config_file = "snake_oil.ert"
rc = ResConfig(user_config_file=config_file)
rc.convertToCReference(None)
ert = EnKFMain(rc)
facade = LibresFacade(ert)
api = PlotApi(facade)
yield api
def test_main_entry_point_block_data_calc():
cos_config = {"CALCULATE_KEYS": {"keys": [{"key": "RFT3"}]}}
test_data_dir = os.path.join(TEST_DATA_DIR, "Equinor", "config",
"with_RFT")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("config")
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["RFT3"]
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == 1.0
CorrelatedObservationsScalingJob(ert).run(cos_config)
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == 2.0
def __init__(self, res_config, controls, results):
"""Will create simulator which can be used to run multiple simulations.
The @res_config argument should be a ResConfig object, representing the
fully configured state of libres.
The @controls argument configures which parameters the simulator should
get when actually simulating. The @controls argument should be a
dictionary like this:
controls = {"cmode": ["Well", "Group"], "order": ["W1", "W2", "W3"]}
In this example the simulator will expect two arrays 'cmode' and
'order', consisting of two and three elements respectively. When
actually simualating these values will be written to json files looking
like:
cmode.json = {"Well": 1.0, "Group": 2.0}
order.json = {"W1": 1, "W2": 1.0, "W3": 1.0}
When later invoking the start() method the simulator expects to get
values for all parameters configured with the @controls argument,
otherwise an exception will be raised. Internally in libres code the
controls will be implemented as 'ext_param' instances.
The @results argument is a list of keys of results which the simulator
expects to be generated by the forward model. If argument @results
looks like:
results = ["CMODE", "order"]
The simulator will look for the files 'CMODE_0' and 'order_0' in the
simulation folder. If those files are not produced by the simulator an
exception will be raised.
"""
if not isinstance(res_config, ResConfig):
raise ValueError("The first argument must be valid ResConfig instance")
self.res_config = res_config
self.ert = EnKFMain(self.res_config)
self.control_keys = tuple(controls.keys())
self.result_keys = tuple(results)
ens_config = self.res_config.ensemble_config
for control_name, variable_names in controls.iteritems():
ens_config.addNode(EnkfConfigNode.create_ext_param(control_name, variable_names))
for key in results:
ens_config.addNode(EnkfConfigNode.create_gen_data(key, "{}_%d".format(key)))
def run_cli(args):
logging.basicConfig(level=logging.INFO, format='%(message)s')
res_config = ResConfig(args.config)
os.chdir(res_config.config_path)
ert = EnKFMain(res_config, strict=True, verbose=args.verbose)
notifier = ErtCliNotifier(ert, args.config)
ERT.adapt(notifier)
if args.mode == WORKFLOW_MODE:
execute_workflow(args.name)
return
model, argument = create_model(args)
if args.disable_monitoring:
model.startSimulations(argument)
if model.hasRunFailed():
_clear_and_exit(model.getFailMessage())
else:
# Test run does not have a current_case
if "current_case" in args and args.current_case:
ERT.enkf_facade.select_or_create_new_case(args.current_case)
if (args.mode in [ENSEMBLE_SMOOTHER_MODE, ITERATIVE_ENSEMBLE_SMOOTHER_MODE, ES_MDA_MODE] and
args.target_case == ERT.enkf_facade.get_current_case_name()):
msg = (
"ERROR: Target file system and source file system can not be the same. "
"They were both: {}.".format(args.target_case)
)
_clear_and_exit(msg)
thread = threading.Thread(
name="ert_cli_simulation_thread",
target=model.startSimulations,
args=(argument,)
)
thread.start()
tracker = create_tracker(model, detailed_interval=0)
monitor = Monitor(color_always=args.color_always)
try:
monitor.monitor(tracker)
except (SystemExit, KeyboardInterrupt):
print("\nKilling simulations...")
tracker.request_termination()
thread.join()
if model.hasRunFailed():
_clear_and_exit(1) # the monitor has already reported the error message
def __enter__(self):
self._dir_before = os.getcwd()
os.chdir(self._tmp_dir)
try:
dir = pathlib.Path(self._model_config).parent
config = pathlib.Path(self._model_config).name
copy_tree(dir, self._tmp_dir)
self._res_config = ResConfig(user_config_file=config)
self._ert = EnKFMain(self._res_config, strict=True)
except Exception:
os.chdir(self._dir_before)
shutil.rmtree(self._tmp_dir)
raise
return self
def test_executing_workflow(self):
with open("test_wf", "w") as wf_file:
wf_file.write("EXPORT_RUNPATH")
config_file = "poly.ert"
with open(config_file, "a") as file:
file.write("LOAD_WORKFLOW test_wf")
rc = ResConfig(user_config_file=config_file)
rc.convertToCReference(None)
ert = EnKFMain(rc)
args = Namespace(name="test_wf")
execute_workflow(ert, args.name)
assert os.path.isfile(".ert_runpath_list")
def test_gen_obs_runtime(monkeypatch, copy_snake_oil, snapshot):
obs_file = pathlib.Path.cwd() / "observations" / "observations.txt"
with obs_file.open(mode="a") as fin:
fin.write(create_general_observation())
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
facade = LibresFacade(ert)
df = MeasuredData(facade,
[f"CUSTOM_DIFF_{restart}" for restart in range(500)])
snapshot.assert_match(df.data.to_csv(), "snake_oil_gendata_output.csv")
def test_ahmanalysis_run(test_data_root):
"""test data_set with only scalar parameters"""
test_data_dir = os.path.join(test_data_root, "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
res_config.convertToCReference(None)
ert = EnKFMain(res_config)
ahmanalysis.AhmAnalysisJob(ert).run(prior_name="default_0")
# assert that this returns/generates a KS csv file
output_dir = Path("storage/snake_oil/reports/default_0/AhmAnalysisJob")
group_obs = [
"FOPR",
"WOPR_OP1",
"SNAKE_OIL_WPR_DIFF",
"All_obs",
"All_obs-SNAKE_OIL_WPR_DIFF",
"All_obs-WOPR_OP1",
"All_obs-FOPR",
]
parameters = [
"SNAKE_OIL_PARAM:OP1_PERSISTENCE",
"SNAKE_OIL_PARAM:OP1_OCTAVES",
"SNAKE_OIL_PARAM:OP1_DIVERGENCE_SCALE",
"SNAKE_OIL_PARAM:OP1_OFFSET",
"SNAKE_OIL_PARAM:OP2_PERSISTENCE",
"SNAKE_OIL_PARAM:OP2_OCTAVES",
"SNAKE_OIL_PARAM:OP2_DIVERGENCE_SCALE",
"SNAKE_OIL_PARAM:OP2_OFFSET",
"SNAKE_OIL_PARAM:BPR_555_PERSISTENCE",
"SNAKE_OIL_PARAM:BPR_138_PERSISTENCE",
]
assert (output_dir / "ks.csv").is_file()
ks_df = pd.read_csv(output_dir / "ks.csv")
for keys in ks_df["Parameters"].tolist():
assert keys in parameters
assert ks_df.columns[1:].tolist() == group_obs
assert ks_df["WOPR_OP1"].max() <= 1
assert ks_df["WOPR_OP1"].min() >= 0
assert (output_dir / "active_obs_info.csv").is_file()
assert (output_dir / "misfit_obs_info.csv").is_file()
assert (output_dir / "prior.csv").is_file()
for group in group_obs:
filename = group + ".csv"
assert (output_dir / filename).is_file()
def main():
# The ert_cli script should be called from ert.in. The arguments are parsed and verified in ert.in
if len(sys.argv) < 3:
raise AssertionError(
"Required arguments are missing, the config-file, "
"mode and target case must be provided")
config_file, mode, target_case = sys.argv[1:]
config = resconfig(config_file)
ert = EnKFMain(config)
if not ert._real_enkf_main().have_observations(
) and mode == 'ensemble_smoother':
logging.error(
"No observations loaded. Unable to perform model update.")
return
if mode == "test_run":
_test_run(ert)
if mode == "ensemble_experiment":
_experiment_run(ert)
if mode == "ensemble_smoother":
_ensemble_smoother_run(ert, target_case)
def test_add_observation_vectors():
valid_config_data = {"UPDATE_KEYS": {"keys": [{"key": "WOPR_OP1_108"}]}}
schema = job_config.build_schema()
config = configsuite.ConfigSuite(valid_config_data, schema, deduce_required=True)
test_data_dir = os.path.join(TEST_DATA_DIR, "local", "snake_oil_field")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
obs = ert.getObservations()
new_events = create_active_lists(obs, config.snapshot.UPDATE_KEYS.keys)
keys = [event.key for event in new_events]
assert "WOPR_OP1_108" in keys
assert "WOPR_OP1_144" not in keys
def test_gen_obs_runtime(monkeypatch, copy_snake_oil):
obs_file = pathlib.Path.cwd() / "observations" / "observations.txt"
with obs_file.open(mode="a") as fin:
fin.write(create_general_observation())
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
facade = LibresFacade(ert)
df = MeasuredData(facade,
[f"CUSTOM_DIFF_{restart}" for restart in range(1, 500)])
df.remove_inactive_observations()
assert df.data.shape == (27, 1995)
def test_main_entry_point_shielded_data(setup_ert, monkeypatch):
cos_config = {
"CALCULATE_KEYS": {"keys": [{"key": "FOPR", "index": [1, 2, 3, 4, 5]}]}
}
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["FOPR"]
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == 1.0
monkeypatch.setattr(
cos.ObservationScaleFactor, "get_scaling_factor", MagicMock(return_value=1.23)
)
CorrelatedObservationsScalingJob(ert).run(cos_config)
for index, node in enumerate(obs_vector):
if index in [1, 2, 3, 4, 5]:
assert node.getStdScaling(index) == 1.23, f"index: {index}"
else:
assert node.getStdScaling(index) == 1.0, f"index: {index}"
def test_misfit_preprocessor_all_obs(test_data_root, monkeypatch):
from unittest.mock import MagicMock
from semeio.workflows.correlated_observations_scaling import cos
test_data_dir = os.path.join(test_data_root, "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
monkeypatch.setattr(cos.ObservationScaleFactor, "get_scaling_factor",
MagicMock(return_value=1.234))
misfit_preprocessor.MisfitPreprocessorJob(ert).run()
scaling_factors = []
obs = ert.getObservations()
for key in [
"FOPR",
"WOPR_OP1_9",
"WOPR_OP1_36",
"WOPR_OP1_72",
"WOPR_OP1_108",
"WOPR_OP1_144",
"WOPR_OP1_190",
"WPR_DIFF_1",
]:
obs_vector = obs[key]
for index, node in enumerate(obs_vector):
scaling_factors.append((index, key, node.getStdScaling(index)))
for index, key, scaling_factor in scaling_factors:
assert scaling_factor == 1.234, f"{index}, {key}"
def loadAllSummaryData(ert: EnKFMain, case_name, keys=None, realization_index=None):
"""
@type ert: EnKFMain
@type case_name: str
@type keys: list of str
@rtype: DataFrame
"""
fs = ert.getEnkfFsManager().getFileSystem(case_name)
time_map = fs.getTimeMap()
dates = [time_map[index].datetime() for index in range(1, len(time_map))]
realizations = SummaryCollector.createActiveList(ert, fs)
if realization_index is not None:
if realization_index not in realizations:
raise IndexError(f"No such realization {realization_index}")
realizations = [realization_index]
summary_keys = SummaryCollector.getAllSummaryKeys(ert)
if keys is not None:
summary_keys = [
key for key in keys if key in summary_keys
] # ignore keys that doesn't exist
summary_data = _lib.enkf_fs_summary_data.get_summary_data(
ert.ensembleConfig(), fs, summary_keys, realizations, len(dates)
)
multi_index = MultiIndex.from_product(
[realizations, dates], names=["Realization", "Date"]
)
df = DataFrame(data=summary_data, index=multi_index, columns=summary_keys)
return df
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 test_executing_workflow(self):
with open('test_wf', 'w') as wf_file:
wf_file.write('EXPORT_RUNPATH')
config_file = 'poly.ert'
with open(config_file, 'a') as file:
file.write("LOAD_WORKFLOW test_wf")
rc = ResConfig(user_config_file=config_file)
rc.convertToCReference(None)
ert = EnKFMain(rc)
notifier = ErtCliNotifier(ert, config_file)
ERT.adapt(notifier)
args = Namespace(name="test_wf")
execute_workflow(args.name)
assert os.path.isfile(".ert_runpath_list")
def test_misfit_preprocessor_skip_clusters_yielding_empty_data_matrixes(
monkeypatch, test_data_root):
def raising_scaling_job(data):
if data == {
"CALCULATE_KEYS": {
"keys": [{
"index": [88, 89],
"key": "FOPR"
}]
}
}:
raise EmptyDatasetException("foo")
scaling_mock = Mock(return_value=Mock(
**{"run.side_effect": raising_scaling_job}))
monkeypatch.setattr(misfit_preprocessor,
"CorrelatedObservationsScalingJob", scaling_mock)
test_data_dir = os.path.join(test_data_root, "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
config = {
"workflow": {
"type": "custom_scale",
"clustering": {
"fcluster": {
"threshold": 1.0
}
},
},
}
config_file = "my_config_file.yaml"
with open(config_file, "w") as f:
yaml.dump(config, f)
job = misfit_preprocessor.MisfitPreprocessorJob(ert)
try:
job.run(config_file)
except EmptyDatasetException:
pytest.fail(
"EmptyDatasetException was not handled by misfit preprocessor")
def main(argv):
app = QApplication(argv) #Early so that QT is initialized before other imports
app.setWindowIcon(resourceIcon("application/window_icon_cutout"))
if len(argv) == 1:
sys.stderr.write("Missing configuration file")
sys.exit(1)
config_file = argv[1]
strict = True
if not os.path.exists(config_file):
print("Can not run without a configuration file.")
sys.exit(1)
if os.path.isdir(config_file):
print("The specified configuration file is a directory!")
sys.exit(1)
splash = ErtSplash()
splash.version = "Version %s" % Version.getVersion()
splash.timestamp = Version.getBuildTime()
splash.show()
splash.repaint()
now = time.time()
res_config = ResConfig(config_file)
ert = EnKFMain(res_config, strict=strict, verbose=False)
ert_gui.configureErtNotifier(ert, config_file)
window = PlotWindow(ert, None)
sleep_time = 2 - (time.time() - now)
if sleep_time > 0:
time.sleep(sleep_time)
window.show()
splash.finish(window)
window.activateWindow()
window.raise_()
finished_code = app.exec_()
sys.exit(finished_code)
def test_main_entry_point_gen_data(monkeypatch, test_data_root):
run_mock = Mock()
scal_job = Mock(return_value=Mock(run=run_mock))
monkeypatch.setattr(sc, "CorrelatedObservationsScalingJob", scal_job)
test_data_dir = os.path.join(test_data_root, "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
sc.SpearmanCorrelationJob(ert).run(*["-t", "1.0"])
# call_args represents the clusters, we expect the snake_oil
# observations to generate this amount of them
# call_args is a call object, which itself is a tuple of args and kwargs.
# In this case, we want args, and the first element of the arguments, which
# again is a tuple containing the configuration which is a list of configs.
assert len(list(
run_mock.call_args)[0][0]) == 47, "wrong number of clusters"
cor_matrix_file = os.path.join(
"storage",
"snake_oil",
"reports",
"default_0",
"SpearmanCorrelationJob",
"correlation_matrix.csv",
)
pd.read_csv(cor_matrix_file, index_col=[0, 1], header=[0, 1])
clusters_file = os.path.join(
"storage",
"snake_oil",
"reports",
"default_0",
"SpearmanCorrelationJob",
"clusters.json",
)
with open(clusters_file) as f:
cluster_reports = json.load(f)
assert len(cluster_reports) == 1
clusters = cluster_reports[0]
assert len(clusters.keys()) == 47
def test_main_entry_point_gen_data(monkeypatch):
scal_job = Mock()
monkeypatch.setattr(spearman, "scaling_job", scal_job)
test_data_dir = os.path.join(TEST_DATA_DIR, "local", "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
facade = LibresFacade(ert)
spearman.spearman_job(facade, 1.0, False)
assert scal_job.call_count == 71
def getObservationKeyForDataKey(ert: EnKFMain, data_key, data_report_step):
"""
@type ert: EnKFMain
@rtype: str
"""
observation_key = None
enkf_obs = ert.getObservations()
for obs_vector in enkf_obs:
if EnkfObservationImplementationType.GEN_OBS:
report_step = obs_vector.firstActiveStep()
key = obs_vector.getDataKey()
if key == data_key and report_step == data_report_step:
observation_key = obs_vector.getObservationKey()
return observation_key
def test_ecl_config_creation(self):
with TestAreaContext("enkf_library_test") as work_area:
work_area.copy_directory(self.case_directory)
res_config = ResConfig("simple_config/minimum_config")
main = EnKFMain(res_config)
self.assertIsInstance(main.analysisConfig(), AnalysisConfig)
self.assertIsInstance(main.eclConfig(), EclConfig)
with self.assertRaises(AssertionError): # Null pointer!
self.assertIsInstance(main.eclConfig().getRefcase(), EclSum)
file_system = main.getEnkfFsManager().getCurrentFileSystem()
self.assertEqual(file_system.getCaseName(), "default")
time_map = file_system.getTimeMap()
self.assertIsInstance(time_map, TimeMap)
main.free()
def test_snapshot_alpha(setup_case, alpha, expected):
"""
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")
obs_file = Path("observations") / "observations.txt"
with obs_file.open(mode="w") as fin:
fin.write(
"""
SUMMARY_OBSERVATION LOW_STD
{
VALUE = 10;
ERROR = 0.1;
DATE = 2015-06-23;
KEY = FOPR;
};
SUMMARY_OBSERVATION HIGH_STD
{
VALUE = 10;
ERROR = 1.0;
DATE = 2015-06-23;
KEY = FOPR;
};
SUMMARY_OBSERVATION EXTREMELY_HIGH_STD
{
VALUE = 10;
ERROR = 10.0;
DATE = 2015-06-23;
KEY = FOPR;
};
"""
)
ert = EnKFMain(res_config)
es_update = ESUpdate(ert)
ert.analysisConfig().selectModule("IES_ENKF")
fsm = ert.getEnkfFsManager()
sim_fs = fsm.getFileSystem("default_0")
target_fs = fsm.getFileSystem("target")
run_context = ErtRunContext.ensemble_smoother_update(sim_fs, target_fs)
ert.analysisConfig().setEnkfAlpha(alpha)
es_update.smootherUpdate(run_context)
result_snapshot = ert.update_snapshots[run_context.get_id()]
assert result_snapshot.alpha == alpha
assert result_snapshot.ministep_snapshots["ALL_ACTIVE"].obs_status == expected
def test_run_export():
with ErtPluginContext():
config_file = "snake_oil.ert"
rc = ResConfig(user_config_file=config_file)
rc.convertToCReference(None)
ert = EnKFMain(rc)
ex = Exporter(ert)
parameters = {
"output_file": "export.csv",
"time_index": "raw",
"column_keys": "FOPR",
}
ex.run_export(parameters)
shutil.rmtree("storage")
with pytest.raises(UserWarning) as warn:
ex.run_export(parameters)
assert ex._export_job in str(warn)
def test_misfit_preprocessor_main_entry_point_no_config(monkeypatch):
run_mock = Mock()
scal_job = Mock(return_value=Mock(run=run_mock))
monkeypatch.setattr(
misfit_preprocessor, "CorrelatedObservationsScalingJob", scal_job,
)
test_data_dir = os.path.join(TEST_DATA_DIR, "local", "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
misfit_preprocessor.MisfitPreprocessorJob(ert).run()
assert len(run_mock.call_args[0][0]) > 1
def test_misfit_preprocessor_main_entry_point_gen_data(monkeypatch,
test_data_root,
observation,
expected_nr_clusters):
run_mock = Mock()
scal_job = Mock(return_value=Mock(run=run_mock))
monkeypatch.setattr(
misfit_preprocessor,
"CorrelatedObservationsScalingJob",
scal_job,
)
test_data_dir = os.path.join(test_data_root, "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
config = {
"observations": [observation],
"workflow": {
"type": "custom_scale",
"clustering": {
"fcluster": {
"threshold": 1.0
}
},
},
}
config_file = "my_config_file.yaml"
with open(config_file, "w") as f:
yaml.dump(config, f)
misfit_preprocessor.MisfitPreprocessorJob(ert).run(config_file)
# call_args represents the clusters, we expect the snake_oil
# observations to generate this amount of them
# call_args is a call object, which itself is a tuple of args and kwargs.
# In this case, we want args, and the first element of the arguments, which
# again is a tuple containing the configuration which is a list of configs.
assert (len(list(run_mock.call_args)[0][0]) == expected_nr_clusters
), "wrong number of clusters"
def test_load_inconsistent_time_map_summary(copy_data, caplog):
"""
Checking that we dont util_abort, we fail the forward model instead
"""
cwd = os.getcwd()
# Get rid of GEN_DATA as we are only interested in SUMMARY
with fileinput.input("snake_oil.ert", inplace=True) as fin:
for line in fin:
if line.startswith("GEN_DATA"):
continue
print(line, end="")
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
facade = LibresFacade(ert)
realisation_number = 0
assert (facade.get_current_fs().getStateMap()[realisation_number].name ==
"STATE_HAS_DATA") # Check prior state
# Create a result that is incompatible with the refcase
run_path = Path(
"storage") / "snake_oil" / "runpath" / "realization-0" / "iter-0"
os.chdir(run_path)
ecl_sum = run_simulator(1, datetime(2000, 1, 1))
ecl_sum.fwrite()
os.chdir(cwd)
realizations = BoolVector(default_value=False,
initial_size=facade.get_ensemble_size())
realizations[realisation_number] = True
with caplog.at_level(logging.ERROR):
loaded = facade.load_from_forward_model("default_0", realizations, 0)
assert (
f"""Inconsistency in time_map - loading SUMMARY from: {run_path.absolute()} failed:
Time mismatch for step: 1, new time: 2000-01-10, reference case: 2010-01-10
""" in caplog.messages)
assert (
f"Inconsistent time map for summary data from: {run_path.absolute()}"
f"/SNAKE_OIL_FIELD, realisation failed" in caplog.messages)
assert loaded == 0
assert (facade.get_current_fs().getStateMap()[realisation_number].name ==
"STATE_LOAD_FAILURE") # Check that status is as expected
def __init__(self,
config,
host="localhost",
port=0,
log_requests=False,
verbose_queue=False):
SimpleXMLRPCServer.__init__(self, (host, port),
allow_none=True,
logRequests=log_requests)
self._host = host
self._verbose_queue = verbose_queue
# https: server.socket = ssl.wrap_socket(srv.socket, ...)
if isinstance(config, EnKFMain):
self._config = config
self._config_file = config.getUserConfigFile()
else:
if os.path.exists(config):
self._config = EnKFMain(config)
self._config_file = config
else:
raise IOError("The ert config file: %s does not exist" %
config)
self._session = Session()
self.register_function(self.ertVersion)
self.register_function(self.getTimeMap)
self.register_function(self.isRunning)
self.register_function(self.isInitializationCaseAvailable)
self.register_function(self.startSimulationBatch)
self.register_function(self.addSimulation)
self.register_function(self.isRealizationFinished)
self.register_function(self.didRealizationSucceed)
self.register_function(self.didRealizationFail)
self.register_function(self.getGenDataResult)
self.register_function(self.getCustomKWResult)
self.register_function(self.isCustomKWKey)
self.register_function(self.isGenDataKey)
self.register_function(self.prototypeStorage)
self.register_function(self.storeGlobalData)
self.register_function(self.storeSimulationData)
def test_main_entry_point_gen_data(monkeypatch):
run_mock = Mock()
scal_job = Mock(return_value=Mock(run=run_mock))
monkeypatch.setattr(sc, "CorrelatedObservationsScalingJob", scal_job)
test_data_dir = os.path.join(TEST_DATA_DIR, "local", "snake_oil")
shutil.copytree(test_data_dir, "test_data")
os.chdir(os.path.join("test_data"))
res_config = ResConfig("snake_oil.ert")
ert = EnKFMain(res_config)
sc.SpearmanCorrelationJob(ert).run(*["-t", "1.0"])
# call_args represents the clusters, we expect the snake_oil
# observations to generate this amount of them
# call_args is a call object, which itself is a tuple of args and kwargs.
# In this case, we want args, and the first element of the arguments, which
# again is a tuple containing the configuration which is a list of configs.
assert len(run_mock.call_args[0][0]) == 47, "wrong number of clusters"
#!/usr/bin/env python
import sys
import time
from res.enkf import EnKFMain, ResConfig
# 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 )
site_config = ert.siteConfig( )
jobs = site_config.get_installed_jobs( )
for job in jobs:
print job.name()
print " config : %s" % job.get_config_file()
print " executable: %s" % job.get_executable( )
print
def main(argv):
app = QApplication(argv) # Early so that QT is initialized before other imports
app.setWindowIcon(resourceIcon("application/window_icon_cutout"))
if len(argv) == 1:
config_file = QFileDialog.getOpenFileName(None, "Open Configuration File")
config_file = str(config_file)
if len(config_file) == 0:
print("-----------------------------------------------------------------")
print("-- You must supply the name of configuration file as the first --")
print("-- commandline argument: --")
print("-- --")
print("-- bash% gert <config_file> --")
print("-- --")
print("-- If the configuration file does not exist, gert will create --")
print("-- create a new configuration file. --")
print("-----------------------------------------------------------------")
sys.exit(1)
else:
config_file = argv[1]
help_center = HelpCenter("ERT")
help_center.setHelpLinkPrefix(os.getenv("ERT_SHARE_PATH") + "/gui/help/")
help_center.setHelpMessageLink("welcome_to_ert")
strict = True
verbose = False
verbose_var = os.getenv("ERT_VERBOSE", "False")
lower_verbose_var = verbose_var.lower()
if lower_verbose_var == "true":
verbose = True
if not os.path.exists(config_file):
print("Trying to start new config")
new_configuration_dialog = NewConfigurationDialog(config_file)
success = new_configuration_dialog.exec_()
if not success:
print("Can not run without a configuration file.")
sys.exit(1)
else:
config_file = new_configuration_dialog.getConfigurationPath()
dbase_type = new_configuration_dialog.getDBaseType()
num_realizations = new_configuration_dialog.getNumberOfRealizations()
storage_path = new_configuration_dialog.getStoragePath()
EnKFMain.createNewConfig(config_file, storage_path, dbase_type, num_realizations)
strict = False
if os.path.isdir(config_file):
print("The specified configuration file is a directory!")
sys.exit(1)
splash = ErtSplash()
version = ErtVersion( )
splash.version = "Version %s" % version.versionString()
splash.timestamp = version.getBuildTime()
splash.show()
splash.repaint()
now = time.time()
res_config = ResConfig(config_file)
os.chdir( res_config.config_path )
ert = EnKFMain(res_config, strict=strict, verbose=verbose)
ert_gui.configureErtNotifier(ert, config_file)
window = GertMainWindow()
window.setWidget(SimulationPanel())
plugin_handler = PluginHandler(ert, ert.getWorkflowList().getPluginJobs(), window)
help_tool = HelpTool("ERT", window)
window.addDock("Configuration Summary", SummaryPanel(), area=Qt.BottomDockWidgetArea)
window.addTool(IdeTool(os.path.basename(config_file), help_tool))
window.addTool(PlotTool())
window.addTool(ExportTool())
window.addTool(WorkflowsTool())
window.addTool(ManageCasesTool())
window.addTool(PluginsTool(plugin_handler))
window.addTool(RunAnalysisTool())
window.addTool(LoadResultsTool())
window.addTool(help_tool)
sleep_time = 2 - (time.time() - now)
if sleep_time > 0:
time.sleep(sleep_time)
window.show()
splash.finish(window)
window.activateWindow()
window.raise_()
ResLog.log(3, "Versions ecl:%s res:%s ert:%s" % (EclVersion( ), ResVersion( ), ErtVersion( )))
finished_code = app.exec_()
ert.free()
sys.exit(finished_code)
#!/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, 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( )))
def main(argv):
app = QApplication(argv) # Early so that QT is initialized before other imports
app.setWindowIcon(resourceIcon("application/window_icon_cutout"))
# There seems to be a setlocale() call deep down in the initialization of
# QApplication, if the user has set the LC_NUMERIC environment variables to
# a locale with decimalpoint different from "." the application will fail
# hard quite quickly.
current_locale = QLocale()
decimal_point = str(current_locale.decimalPoint())
if decimal_point != ".":
msg = """
** WARNING: You are using a locale with decimalpoint: '{}' - the ert application is
written with the assumption that '.' is used as decimalpoint, and chances
are that something will break if you continue with this locale. It is highly
reccomended that you set the decimalpoint to '.' using one of the environment
variables 'LANG', LC_ALL', or 'LC_NUMERIC' to either the 'C' locale or
alternatively a locale which uses '.' as decimalpoint.\n""".format(decimal_point)
sys.stderr.write(msg)
if len(argv) == 1:
config_file = QFileDialog.getOpenFileName(None, "Open Configuration File")
config_file = str(config_file)
if len(config_file) == 0:
print("-----------------------------------------------------------------")
print("-- You must supply the name of configuration file as the first --")
print("-- commandline argument: --")
print("-- --")
print("-- bash% gert <config_file> --")
print("-- --")
print("-- If the configuration file does not exist, gert will create --")
print("-- create a new configuration file. --")
print("-----------------------------------------------------------------")
sys.exit(1)
else:
config_file = argv[1]
help_center = HelpCenter("ERT")
help_center.setHelpLinkPrefix(ert_share_path + "/gui/help/")
help_center.setHelpMessageLink("welcome_to_ert")
strict = True
verbose = False
verbose_var = os.getenv("ERT_VERBOSE", "False")
lower_verbose_var = verbose_var.lower()
if lower_verbose_var == "true":
verbose = True
if not os.path.exists(config_file):
print("Trying to start new config")
new_configuration_dialog = NewConfigurationDialog(config_file)
success = new_configuration_dialog.exec_()
if not success:
print("Can not run without a configuration file.")
sys.exit(1)
else:
config_file = new_configuration_dialog.getConfigurationPath()
dbase_type = new_configuration_dialog.getDBaseType()
num_realizations = new_configuration_dialog.getNumberOfRealizations()
storage_path = new_configuration_dialog.getStoragePath()
EnKFMain.createNewConfig(config_file, storage_path, dbase_type, num_realizations)
strict = False
if os.path.isdir(config_file):
print("The specified configuration file is a directory!")
sys.exit(1)
splash = ErtSplash()
version = ErtVersion( )
splash.version = "Version %s" % version.versionString()
splash.timestamp = version.getBuildTime()
splash.show()
splash.repaint()
now = time.time()
res_config = ResConfig(config_file)
os.chdir( res_config.config_path )
ert = EnKFMain(res_config, strict=strict, verbose=verbose)
ert_gui.configureErtNotifier(ert, config_file)
window = GertMainWindow()
window.setWidget(SimulationPanel())
plugin_handler = PluginHandler(ert, ert.getWorkflowList().getPluginJobs(), window)
help_tool = HelpTool("ERT", window)
window.addDock("Configuration Summary", SummaryPanel(), area=Qt.BottomDockWidgetArea)
window.addTool(IdeTool(os.path.basename(config_file), help_tool))
window.addTool(PlotTool())
window.addTool(ExportTool())
window.addTool(WorkflowsTool())
window.addTool(ManageCasesTool())
window.addTool(PluginsTool(plugin_handler))
window.addTool(RunAnalysisTool())
window.addTool(LoadResultsTool())
window.addTool(help_tool)
sleep_time = 2 - (time.time() - now)
if sleep_time > 0:
time.sleep(sleep_time)
window.show()
splash.finish(window)
window.activateWindow()
window.raise_()
ResLog.log(3, "Versions ecl:%s res:%s ert:%s" % (EclVersion( ), ResVersion( ), ErtVersion( )))
finished_code = app.exec_()
sys.exit(finished_code)
