def test_main_entry_point_summary_data_calc():
cos_config = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WOPR_OP1_108"
}, {
"key": "WOPR_OP1_144"
}]
}
}
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)
obs = ert.getObservations()
obs_vector = obs["WOPR_OP1_108"]
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) == np.sqrt(1.0)
def loadObservationData(ert: EnKFMain, case_name, keys=None):
"""
@type ert: EnKFMain
@type case_name: str
@type keys: list of str
@rtype: DataFrame
"""
observations = ert.getObservations()
history_length = ert.getHistoryLength()
dates = [
observations.getObservationTime(index).datetime()
for index in range(1, history_length + 1)
]
summary_keys = SummaryObservationCollector.getAllObservationKeys(ert)
if keys is not None:
summary_keys = [key for key in keys if key in summary_keys
] # ignore keys that doesn't exist
columns = summary_keys
std_columns = ["STD_%s" % key for key in summary_keys]
df = DataFrame(index=dates, columns=columns + std_columns)
for key in summary_keys:
observation_keys = ert.ensembleConfig().getNode(
key).getObservationKeys()
for obs_key in observation_keys:
observation_data = observations[obs_key]
for index in range(0, history_length + 1):
if observation_data.isActive(index):
obs_time = observations.getObservationTime(
index).datetime()
node = observation_data.getNode(index)
value = node.getValue()
std = node.getStandardDeviation()
df[key][obs_time] = value
df["STD_%s" % key][obs_time] = std
return df
def test_create_observation_vectors(setup_ert):
valid_config_data = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
"UPDATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
}
config = configsuite.ConfigSuite(
valid_config_data,
job_config._CORRELATED_OBSERVATIONS_SCHEMA,
deduce_required=True,
)
res_config = setup_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 "WPR_DIFF_1" in keys
assert "SNAKE_OIL_WPR_DIFF" not in keys
def test_add_observation_vectors(test_data_root):
valid_config_data = {"UPDATE_KEYS": {"keys": [{"key": "WOPR_OP1_108"}]}}
schema = job_config._CORRELATED_OBSERVATIONS_SCHEMA
config = configsuite.ConfigSuite(valid_config_data,
schema,
deduce_required=True)
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)
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_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)
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 = job._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_main_entry_point_block_and_summary_data_calc():
arguments = {
"CALCULATE_KEYS": {
"keys": [{
"key": "FOPT"
}, {
"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)
facade = LibresFacade(ert)
obs = ert.getObservations()
obs_vector = obs["RFT3"]
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == 1.0
scaling_job.scaling_job(facade, arguments)
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == np.sqrt(64)
def test_compare_different_jobs():
arguments = {"CALCULATE_KEYS": {"keys": [{"key": "WPR_DIFF_1"}]}}
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)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0)
job = ert.getWorkflowList().getJob("STD_SCALE_CORRELATED_OBS")
job.run(ert, ["WPR_DIFF_1"])
# Result of old job:
assert_obs_vector(obs_vector, np.sqrt(4 / 2))
scaling_job.scaling_job(facade, arguments)
# Result of new job with no sub-indexing:
assert_obs_vector(obs_vector, np.sqrt(4 / 2))
def test_misfit_preprocessor_with_scaling(test_data_root):
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)
misfit_preprocessor.MisfitPreprocessorJob(ert).run(config_file)
# assert that this arbitrarily chosen cluster gets scaled as expected
obs = ert.getObservations()["FOPR"]
for index in [13, 14, 15, 16, 17, 18, 19, 20]:
assert obs.getNode(index).getStdScaling() == 2.8284271247461903
for index in (38, 39, 40, 41, 42, 43, 44):
assert obs.getNode(index).getStdScaling() == 2.6457513110645907
def test_main_entry_point_summary_data_update():
cos_config = {
"CALCULATE_KEYS": {"keys": [{"key": "WWCT:OP_1"}, {"key": "WWCT:OP_2"}]},
"UPDATE_KEYS": {"keys": [{"key": "WWCT:OP_2", "index": [1, 2, 3, 4, 5]}]},
}
test_data_dir = os.path.join(TEST_DATA_DIR, "Equinor", "config", "obs_testing")
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["WWCT:OP_2"]
CorrelatedObservationsScalingJob(ert).run(cos_config)
for index, node in enumerate(obs_vector):
if index in cos_config["UPDATE_KEYS"]["keys"][0]["index"]:
assert node.getStdScaling(index) == np.sqrt(61.0 * 2.0)
else:
assert node.getStdScaling(index) == 1.0
obs_vector = obs["WWCT:OP_1"]
CorrelatedObservationsScalingJob(ert).run(cos_config)
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == 1.0
def loadAllMisfitData(ert: EnKFMain, case_name) -> DataFrame:
"""
@type ert: EnKFMain
@type case_name: str
@rtype: DataFrame
"""
fs = ert.getEnkfFsManager().getFileSystem(case_name)
realizations = MisfitCollector.createActiveList(ert, fs)
misfit_keys = ert.getKeyManager().misfitKeys(sort_keys=False)
misfit_sum_index = len(misfit_keys) - 1
misfit_array = numpy.empty(shape=(len(misfit_keys), len(realizations)),
dtype=numpy.float64)
misfit_array.fill(numpy.nan)
misfit_array[misfit_sum_index] = 0.0
for column_index, obs_vector in enumerate(ert.getObservations()):
for realization_index, realization_number in enumerate(
realizations):
misfit = obs_vector.getTotalChi2(fs, realization_number)
misfit_array[column_index][realization_index] = misfit
misfit_array[misfit_sum_index][realization_index] += misfit
misfit_data = DataFrame(data=numpy.transpose(misfit_array),
index=realizations,
columns=misfit_keys)
misfit_data.index.name = "Realization"
return misfit_data
def test_installed_python_version_of_enkf_scaling_job(setup_ert, monkeypatch):
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0)
job_config = {"CALCULATE_KEYS": {"keys": [{"key": "WPR_DIFF_1"}]}}
with open("job_config.yml", "w") as fout:
yaml.dump(job_config, fout)
ert.getWorkflowList().addJob(
"CORRELATE_OBSERVATIONS_SCALING",
os.path.join(get_job_dir(), "CORRELATED_OBSERVATIONS_SCALING"),
)
job = ert.getWorkflowList().getJob("CORRELATE_OBSERVATIONS_SCALING")
job.run(ert, ["job_config.yml"])
assert_obs_vector(obs_vector, np.sqrt(4.0 / 2.0))
job_config["CALCULATE_KEYS"]["keys"][0].update({"index": [400, 800, 1200]})
with open("job_config.yml", "w") as fout:
yaml.dump(job_config, fout)
job.run(ert, ["job_config.yml"])
assert_obs_vector(
obs_vector,
np.sqrt(4.0 / 2.0),
index_list=[0, 1, 2],
val_2=np.sqrt(3.0 / 2.0),
)
def test_create_observation_vectors(setup_ert):
valid_config_data = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
"UPDATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
}
config = configsuite.ConfigSuite(valid_config_data,
job_config.build_schema())
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
new_events = job._create_active_lists(obs,
config.snapshot.UPDATE_KEYS.keys)
keys = [event.key for event in new_events]
assert "WPR_DIFF_1" in keys
assert "SNAKE_OIL_WPR_DIFF" not in keys
def test_misfit_preprocessor_with_scaling(test_data_root):
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 = {
"clustering": {
"method": "spearman_correlation",
"spearman_correlation": {
"fcluster": {
"t": 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)
# assert that this arbitrarily chosen cluster gets scaled as expected
obs = ert.getObservations()["FOPR"]
for index in [13, 14, 15, 16, 17, 18, 19, 20]:
assert obs.getNode(index).getStdScaling() == 2.8284271247461903
def test_compare_different_jobs(test_data_root):
cos_config = {"CALCULATE_KEYS": {"keys": [{"key": "WPR_DIFF_1"}]}}
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)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0)
job = ert.getWorkflowList().getJob("STD_SCALE_CORRELATED_OBS")
job.run(ert, ["WPR_DIFF_1"])
# Result of old job:
assert_obs_vector(obs_vector, np.sqrt(4 / 2))
CorrelatedObservationsScalingJob(ert).run(cos_config)
# Result of new job with no sub-indexing:
assert_obs_vector(obs_vector, np.sqrt(4 / 2))
def test_main_entry_point_gen_data():
cos_config = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
"UPDATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1",
"index": [400, 800]
}]
},
}
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)
CorrelatedObservationsScalingJob(ert).run(cos_config)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0, [0, 1], np.sqrt(4 / 2))
cos_config["CALCULATE_KEYS"]["keys"][0].update({"index": [400, 800, 1200]})
CorrelatedObservationsScalingJob(ert).run(cos_config)
assert_obs_vector(
obs_vector,
1.0,
[0, 1],
np.sqrt(3.0 / 2.0),
)
svd_file = (
"storage/snake_oil/ensemble/reports/CorrelatedObservationsScalingJob/svd.json"
)
# Assert that data was published correctly
with open(svd_file) as f:
reported_svd = json.load(f)
assert reported_svd == pytest.approx((
6.531760256452532,
2.0045135017540487,
1.1768827000026516,
), 0.1)
scale_file = ("storage/snake_oil/ensemble/reports/"
"CorrelatedObservationsScalingJob/scale_factor.json")
with open(scale_file) as f:
reported_scalefactor = json.load(f)
assert reported_scalefactor == pytest.approx(1.224744871391589, 0.1)
def getAllObservationKeys(ert: EnKFMain):
"""
@type ert: EnKFMain
@rtype: list of str
"""
enkf_obs = ert.getObservations()
observation_keys = enkf_obs.getTypedKeylist(
EnkfObservationImplementationType.GEN_OBS)
return [key for key in observation_keys]
def test_old_enkf_scaling_job(setup_ert):
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0)
job = ert.getWorkflowList().getJob("STD_SCALE_CORRELATED_OBS")
job.run(ert, ["WPR_DIFF_1"])
assert_obs_vector(obs_vector, np.sqrt(4.0 / 2.0))
def test_scaling(test_data_root):
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"])
# assert that this arbitrarily chosen cluster gets scaled as expected
obs = ert.getObservations()["FOPR"]
for index in [13, 14, 15, 16, 17, 18, 19, 20]:
assert obs.getNode(index).getStdScaling() == 2.8284271247461903
def test_main_entry_point_summary_data_calc():
arguments = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WOPR_OP1_108"
}, {
"key": "WOPR_OP1_144"
}]
}
}
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)
obs = ert.getObservations()
obs_vector = obs["WOPR_OP1_108"]
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == 1.0
scaling_job.scaling_job(facade, arguments)
for index, node in enumerate(obs_vector):
assert node.getStdScaling(index) == np.sqrt((2.0 * 6.0) / 2.0)
arguments["CALCULATE_KEYS"]["keys"][0].update({"index": [1, 2, 3]})
arguments["CALCULATE_KEYS"]["keys"][1].update({"index": [1, 2, 3]})
with pytest.raises(ValueError): # Will give an empty data set
scaling_job.scaling_job(facade, arguments)
arguments["CALCULATE_KEYS"]["keys"][0].update({"index": [8, 35, 71]})
arguments["CALCULATE_KEYS"]["keys"][1].update({"index": [8, 35, 71]})
scaling_job.scaling_job(facade, arguments)
for index, node in enumerate(obs_vector):
if index in arguments["CALCULATE_KEYS"]["keys"][0]["index"]:
assert node.getStdScaling(index) == np.sqrt((2.0 * 6.0) / 1.0)
else:
assert node.getStdScaling(index) == np.sqrt((2.0 * 6.0) / 2.0)
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_main_entry_point_sum_data_update(setup_ert, monkeypatch):
cos_config = {"CALCULATE_KEYS": {"keys": [{"key": "WOPR_OP1_108"}]}}
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["WOPR_OP1_108"]
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):
assert node.getStdScaling(index) == 1.23
def test_main_entry_point_summary_data_calc(setup_ert, monkeypatch):
cos_config = {
"CALCULATE_KEYS": {"keys": [{"key": "WOPR_OP1_108"}, {"key": "WOPR_OP1_144"}]}
}
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["WOPR_OP1_108"]
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) == 1.0
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 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_main_entry_point_gen_data():
arguments = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
"UPDATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1",
"index": [400, 800]
}]
},
}
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)
scaling_job.scaling_job(facade, arguments)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0, [0, 1], np.sqrt(4 / 2))
arguments["CALCULATE_KEYS"]["keys"][0].update({"index": [400, 800, 1200]})
scaling_job.scaling_job(facade, arguments)
assert_obs_vector(
obs_vector,
1.0,
[0, 1],
np.sqrt(3.0 / 2.0),
)
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 test_compare_different_jobs(setup_ert):
cos_config = {"CALCULATE_KEYS": {"keys": [{"key": "WPR_DIFF_1"}]}}
res_config = setup_ert
ert = EnKFMain(res_config)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0)
job = ert.getWorkflowList().getJob("STD_SCALE_CORRELATED_OBS")
job.run(ert, ["WPR_DIFF_1"])
# Result of old job:
assert_obs_vector(obs_vector, np.sqrt(4 / 2))
CorrelatedObservationsScalingJob(ert).run(cos_config)
# Result of new job with no sub-indexing:
assert_obs_vector(obs_vector, np.sqrt(4 / 2))
def test_main_entry_point_gen_data():
cos_config = {
"CALCULATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1"
}]
},
"UPDATE_KEYS": {
"keys": [{
"key": "WPR_DIFF_1",
"index": [400, 800]
}]
},
}
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)
CorrelatedObservationsScalingJob(ert).run(cos_config)
obs = ert.getObservations()
obs_vector = obs["WPR_DIFF_1"]
assert_obs_vector(obs_vector, 1.0, [0, 1], np.sqrt(4 / 2))
cos_config["CALCULATE_KEYS"]["keys"][0].update({"index": [400, 800, 1200]})
CorrelatedObservationsScalingJob(ert).run(cos_config)
assert_obs_vector(
obs_vector,
1.0,
[0, 1],
np.sqrt(3.0 / 2.0),
)
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}"
