def _setup_sim(self, sim_id, controls, file_system):
def _set_ext_param(ext_param, key, assignment):
if isinstance(assignment, dict): # handle suffixes
suffixes = ext_param.config[key]
if len(assignment) != len(suffixes):
raise KeyError(
"Key {} is missing values for these suffixes: {}".
format(
key,
set(suffixes).difference(set(assignment.keys()))))
for suffix, value in assignment.items():
ext_node[key, suffix] = value
else: # assume assignment is a single numerical value
ext_node[key] = assignment
node_id = NodeId(0, sim_id)
if set(controls.keys()) != self.control_keys:
err_msg = "Mismatch between initialized and provided control names."
raise KeyError(err_msg)
for control_name, control in controls.items():
ens_config = self.res_config.ensemble_config
node = EnkfNode(ens_config[control_name])
ext_node = node.as_ext_param()
if len(ext_node) != len(control.keys()):
raise KeyError(("Expected {} variables for control {}, "
"received {}.").format(len(ext_node),
control_name,
len(control.keys())))
for var_name, var_setting in control.items():
_set_ext_param(ext_node, var_name, var_setting)
node.save(file_system, node_id)
def exportFIELD(self, line):
arguments = splitArguments(line)
if len(arguments) >= 1:
ens_config = self.ert().ensembleConfig()
key = arguments[0]
if key in self.supportedFIELDKeys():
config_node = ens_config[key]
if len(arguments) >= 2:
path_fmt = arguments[1]
else:
path_fmt = Export.DEFAULT_EXPORT_PATH % (key, key) + ".grdecl"
if len(arguments) >= 3:
range_string = "".join(arguments[2:])
iens_list = IntVector.active_list(range_string)
else:
ens_size = self.ert().getEnsembleSize()
iens_list = IntVector.createRange(0, ens_size, 1)
fs_manager = self.ert().getEnkfFsManager()
fs = fs_manager.getCurrentFileSystem()
mc = self.ert().getModelConfig()
init_file = config_node.getInitFile(mc.getRunpathFormat())
if init_file:
print('Using init file: %s' % init_file)
EnkfNode.exportMany(config_node, path_fmt, fs, iens_list, arg=init_file)
else:
self.lastCommandFailed("No such FIELD node: %s" % key)
else:
self.lastCommandFailed("Expected at least one argument: <keyword> received: '%s'" % line)
def test_field_export_many(self):
with ErtTestContext("export_test", self.config_file) as test_context:
ert = test_context.getErt()
fs_manager = ert.getEnkfFsManager()
ens_config = ert.ensembleConfig()
config_node = ens_config["PERMX"]
iens_list = IntVector()
iens_list.append(0)
iens_list.append(2)
iens_list.append(4)
fs = fs_manager.getCurrentFileSystem()
# Filename without embedded %d - TypeError
with self.assertRaises(TypeError):
EnkfNode.exportMany(config_node,
"export/with/path/PERMX.grdecl", fs,
iens_list)
EnkfNode.exportMany(config_node,
"export/with/path/PERMX_%d.grdecl", fs,
iens_list)
self.assertTrue(os.path.isfile("export/with/path/PERMX_0.grdecl"))
self.assertTrue(os.path.isfile("export/with/path/PERMX_2.grdecl"))
self.assertTrue(os.path.isfile("export/with/path/PERMX_4.grdecl"))
def getGenDataResult(self, target_case_name, iens, report_step, keyword):
ensemble_config = self.ert.ensembleConfig()
if not self.isRealizationFinished(iens):
raise createFault(
UserWarning,
"The simulation with id: %d is still running." % iens)
if keyword in ensemble_config:
enkf_config_node = self.ert.ensembleConfig().getNode(keyword)
node = EnkfNode(enkf_config_node)
if not node.getImplType() == ErtImplType.GEN_DATA:
raise createFault(UserWarning,
"The keyword is not a GenData keyword.")
gen_data = node.asGenData()
fs = self.ert.getEnkfFsManager().getFileSystem(target_case_name)
node_id = NodeId(report_step, iens)
if node.tryLoad(fs, node_id):
data = gen_data.getData()
return data.asList()
else:
raise createFault(
UserWarning,
"Unable to load data for iens: %d report_step: %d kw: %s for case: %s"
% (iens, report_step, keyword, target_case_name))
else:
raise createFault(KeyError,
"The keyword: %s is not recognized" % keyword)
def getCustomKWResult(self, target_case_name, iens, keyword):
ensemble_config = self.ert.ensembleConfig()
if not self.isRealizationFinished(iens):
raise createFault(
UserWarning,
"The simulation with id: %d is still running." % iens)
if keyword in ensemble_config:
enkf_config_node = self.ert.ensembleConfig().getNode(keyword)
node = EnkfNode(enkf_config_node)
if not node.getImplType() == ErtImplType.CUSTOM_KW:
raise createFault(UserWarning,
"The keyword is not a CustomKW keyword.")
custom_kw = node.asCustomKW()
fs = self.ert.getEnkfFsManager().getFileSystem(target_case_name)
node_id = NodeId(0, iens)
if node.tryLoad(fs, node_id):
config = custom_kw.getConfig()
result = {}
for key in config.getKeys():
result[key] = custom_kw[key]
return result
else:
raise createFault(
UserWarning,
"Unable to load data for iens: %d kw: %s for case: %s" %
(iens, keyword, target_case_name))
else:
raise createFault(KeyError,
"The keyword: %s is not recognized" % keyword)
def loadVector(self, plot_block_data, fs, report_step, realization_number):
"""
@type plot_block_data: PlotBlockData
@type fs: EnkfFs
@type report_step: int
@type realization_number: int
@rtype PlotBlockVector
"""
config_node = self.__obs_vector.getConfigNode()
is_private_container = (
config_node.getImplementationType() == ErtImplType.CONTAINER
)
data_node = EnkfNode(config_node, private=is_private_container)
node_id = NodeId(report_step, realization_number)
if data_node.tryLoad(fs, node_id):
block_obs = self.getBlockObservation(report_step)
data = DoubleVector()
for index in range(len(block_obs)):
value = block_obs.getData(data_node.valuePointer(), index, node_id)
data.append(value)
data.permute(self.__permutation_vector)
plot_block_vector = PlotBlockVector(realization_number, data)
plot_block_data.addPlotBlockVector(plot_block_vector)
def exportFIELD(self, line):
arguments = splitArguments(line)
if len(arguments) >= 1:
ens_config = self.ert().ensembleConfig()
key = arguments[0]
if key in self.supportedFIELDKeys():
config_node = ens_config[key]
if len(arguments) >= 2:
path_fmt = arguments[1]
else:
path_fmt = Export.DEFAULT_EXPORT_PATH % (key, key) + ".grdecl"
if len(arguments) >= 3:
range_string = "".join(arguments[2:])
iens_list = IntVector.active_list(range_string)
else:
ens_size = self.ert().getEnsembleSize()
iens_list = IntVector.createRange(0, ens_size, 1)
fs_manager = self.ert().getEnkfFsManager()
fs = fs_manager.getCurrentFileSystem()
mc = self.ert().getModelConfig()
init_file = config_node.getInitFile(mc.getRunpathFormat())
if init_file:
print('Using init file: %s' % init_file)
EnkfNode.exportMany(config_node, path_fmt, fs, iens_list, arg=init_file)
else:
self.lastCommandFailed("No such FIELD node: %s" % key)
else:
self.lastCommandFailed("Expected at least one argument: <keyword> received: '%s'" % line)
def test_config(self):
keys = ["Key1", "Key2", "Key3"]
with TestAreaContext("enkf_node"):
config = EnkfConfigNode.create_ext_param("key", keys)
node = EnkfNode(config)
ext_node = node.as_ext_param()
ext_config = config.getModelConfig()
ext_node.set_vector([1, 2, 3])
node.ecl_write("path")
d = json.load(open("path/key.json"))
self.assertEqual(d["Key1"], 1)
self.assertEqual(d["Key3"], 3)
def test_field_basics(self):
with ErtTestContext("export_test", self.config_file) as test_context:
ert = test_context.getErt()
ens_config = ert.ensembleConfig()
fc = ens_config["PERMX"].getFieldModelConfig()
pfx = "FieldConfig(type"
rep = repr(fc)
self.assertEqual(pfx, rep[:len(pfx)])
fc_xyz = fc.get_nx(), fc.get_ny(), fc.get_nz()
ex_xyz = 40, 64, 14
self.assertEqual(ex_xyz, fc_xyz)
self.assertEqual(1, fc.get_truncation_mode())
self.assertEqual(0.001, fc.get_truncation_min())
self.assertEqual(-1.0, fc.get_truncation_max())
self.assertEqual("LOG", fc.get_init_transform_name())
self.assertEqual(None, fc.get_output_transform_name())
grid = fc.get_grid()
self.assertEqual(ex_xyz,
(grid.getNX(), grid.getNY(), grid.getNZ()))
field_node = EnkfNode(fc)
self.assertEqual(grid.get_num_active(), len(field_node))
with self.assertRaises(IndexError):
field_node[grid.get_num_active()]
value0 = field_node[0]
def storeSimulationData(self, target_case_name, group_name, keyword, value, sim_id):
fs = self.ert.getEnkfFsManager().getFileSystem(target_case_name)
enkf_config_node = self.ert.ensembleConfig().getNode(group_name)
enkf_node = EnkfNode(enkf_config_node)
self._updateCustomKWConfigSet(fs, enkf_config_node)
self._storeData(enkf_node, fs, group_name, keyword, value, sim_id)
def storeGlobalData(self, target_case_name, group_name, keyword, value):
fs = self.ert.getEnkfFsManager().getFileSystem(target_case_name)
enkf_config_node = self.ert.ensembleConfig().getNode(group_name)
enkf_node = EnkfNode(enkf_config_node)
self._updateCustomKWConfigSet(fs, enkf_config_node)
realizations = fs.realizationList(RealizationStateEnum.STATE_INITIALIZED | RealizationStateEnum.STATE_HAS_DATA)
for realization_number in realizations:
self._storeData(enkf_node, fs, group_name, keyword, value, realization_number)
def results(self):
"""Will return the results of the simulations.
Observe that this function will raise RuntimeError if the simulations
have not been completed. To be certain that the simulations have
completed you can call the join() method which will block until all
simulations have completed.
The function will return all the results which were configured with the
@results when the simulator was created. The results will come as a
list of dictionaries of arrays of double values, i.e. if the @results
argument was:
results = ["CMODE", "order"]
when the simulator was created the results will be returned as:
[ {"CMODE" : [1,2,3], "order" : [1,1,3]},
{"CMODE" : [1,4,1], "order" : [0,7,8]},
None,
{"CMODE" : [6,1,0], "order" : [0,0,8]} ]
For a simulation which consist of a total of four simulations, where the
None value indicates that the simulator was unable to compute a request.
The order of the list corresponds to case_data provided in the start
call.
"""
if self.running():
raise RuntimeError(
"Simulations are still running - need to wait before gettting results"
)
res = []
nodes = [
EnkfNode(self.res_config.ensemble_config[key])
for key in self.result_keys
]
for sim_id in range(len(self)):
node_id = NodeId(0, sim_id)
if not self.didRealizationSucceed(sim_id):
logging.error("Simulation %d (node %s) failed." %
(sim_id, str(node_id)))
res.append(None)
continue
d = {}
for node in nodes:
node.load(self.get_sim_fs(), node_id)
data = node.asGenData().getData()
d[node.name()] = np.array(data)
res.append(d)
return res
def test_field_export(self):
with ErtTestContext("export_test", self.config_file) as test_context:
ert = test_context.getErt()
fs_manager = ert.getEnkfFsManager( )
ens_config = ert.ensembleConfig()
config_node = ens_config["PERMX"]
data_node = EnkfNode( config_node )
node_id = NodeId( 0 , 0 )
fs = fs_manager.getCurrentFileSystem( )
data_node.tryLoad( fs , node_id )
data_node.export("export/with/path/PERMX.grdecl")
self.assertTrue( os.path.isfile("export/with/path/PERMX.grdecl") )
while True:
print("Waiting:%d Running:%d Complete:%d/%d" % (queue_manager.getNumWaiting( ), queue_manager.getNumRunning( ) , queue_manager.getNumSuccess() , queue_manager.getNumFailed( )))
if not queue_manager.isRunning( ):
break
time.sleep( 5 )
ens_config = ert.ensembleConfig( )
data_config = ens_config["SNAKE_OIL_OPR_DIFF"]
param_config = ens_config["SNAKE_OIL_PARAM"]
for iens in range(ert.getEnsembleSize( )):
data_id = NodeId( realization_number = iens,
report_step = 199 )
enkf_node1 = EnkfNode( data_config )
enkf_node1.load( fs , data_id )
gen_data = enkf_node1.asGenData( )
data = gen_data.getData( )
param_id = NodeId( realization_number = iens,
report_step = 0 )
enkf_node2 = EnkfNode( param_config )
enkf_node2.load( fs , param_id )
gen_kw = enkf_node2.asGenKw( )
print sum(data)
for v in gen_kw:
print v
def load_active_masks(self, case1, case2):
with ErtTestContext("gen_data_config_test",
self.config_file) as test_context:
ert = test_context.getErt()
subst_list = ert.resConfig().subst_config.subst_list
fs1 = ert.getEnkfFsManager().getFileSystem(case1)
config_node = ert.ensembleConfig().getNode("TIMESHIFT")
data_node = EnkfNode(config_node)
data_node.tryLoad(fs1, NodeId(60, 0))
active_mask = self._get_active_mask(
config_node.getDataModelConfig())
first_active_mask_length = len(active_mask)
self.assertEqual(first_active_mask_length, 2560)
fs2 = ert.getEnkfFsManager().getFileSystem(case2)
data_node = EnkfNode(config_node)
data_node.tryLoad(fs2, NodeId(60, 0))
active_mask = self._get_active_mask(
config_node.getDataModelConfig())
second_active_mask_len = len(active_mask)
self.assertEqual(second_active_mask_len, 2560)
self.assertEqual(first_active_mask_length, second_active_mask_len)
# Setting one element to False, load different case, check, reload, and check.
self.assertTrue(active_mask[10])
active_mask_modified = active_mask.copy()
active_mask_modified[10] = False
self.updateMask(
config_node.getDataModelConfig(),
60,
fs2,
active_mask_modified,
subst_list,
)
active_mask = self._get_active_mask(
config_node.getDataModelConfig())
self.assertFalse(active_mask[10])
# Load first - check element is true
data_node = EnkfNode(config_node)
data_node.tryLoad(fs1, NodeId(60, 0))
active_mask = self._get_active_mask(
config_node.getDataModelConfig())
self.assertTrue(active_mask[10])
# Reload second again, should now be false at 10, due to the update further up
data_node = EnkfNode(config_node)
data_node.tryLoad(fs2, NodeId(60, 0))
active_mask = self._get_active_mask(
config_node.getDataModelConfig())
self.assertFalse(active_mask[10])
def _initializeRealization(self, sim_fs, geo_id, iens, keywords):
ens_config = self.ert.ensembleConfig()
# Copy all parameter all parameter values which are not given by @keywords from the
# the initialization case to the target case.
geo_case_fs = self.ert.getEnkfFsManager().getFileSystem(
self._session.geo_case)
for kw in ens_config.getKeylistFromVarType(EnkfVarType.PARAMETER):
if not kw in keywords:
config_node = ens_config[kw]
data_node = EnkfNode(config_node)
init_id = NodeId(0, geo_id)
run_id = NodeId(0, iens)
data_node.load(geo_case_fs, init_id)
data_node.save(sim_fs, run_id)
# All the values supplied externally by the keywords list will be written
# directly into the result case.
for key, values in keywords.items():
config_node = ens_config[key]
data_node = EnkfNode(config_node)
gen_kw = data_node.asGenKw()
gen_kw.setValues(values)
run_id = NodeId(0, iens)
data_node.save(sim_fs, run_id)
sim_fs.fsync()
state_map = sim_fs.getStateMap()
state_map[iens] = RealizationStateEnum.STATE_INITIALIZED
while True:
print("Waiting:%d Running:%d Complete:%d/%d" %
(queue_manager.getNumWaiting(), queue_manager.getNumRunning(),
queue_manager.getNumSuccess(), queue_manager.getNumFailed()))
if not queue_manager.isRunning():
break
time.sleep(5)
ens_config = ert.ensembleConfig()
data_config = ens_config["SNAKE_OIL_OPR_DIFF"]
param_config = ens_config["SNAKE_OIL_PARAM"]
for iens in range(ert.getEnsembleSize()):
data_id = NodeId(realization_number=iens, report_step=199)
enkf_node1 = EnkfNode(data_config)
enkf_node1.load(fs, data_id)
gen_data = enkf_node1.asGenData()
data = gen_data.getData()
param_id = NodeId(realization_number=iens, report_step=0)
enkf_node2 = EnkfNode(param_config)
enkf_node2.load(fs, param_id)
gen_kw = enkf_node2.asGenKw()
print sum(data)
for v in gen_kw:
print v
# Using the __getitem__() of GenData which was implemented
def _initializeRealization(self, target_fs, geo_id, iens, keywords):
ens_config = self.ert.ensembleConfig()
for kw in ens_config.getKeylistFromVarType(EnkfVarType.PARAMETER):
if not kw in keywords:
config_node = ens_config[kw]
data_node = EnkfNode(config_node)
init_id = NodeId(0, geo_id)
run_id = NodeId(0, iens)
data_node.load(self._getInitializationCase(), init_id)
data_node.save(target_fs, run_id)
for key, values in keywords.items():
config_node = ens_config[key]
data_node = EnkfNode(config_node)
gen_kw = data_node.asGenKw()
gen_kw.setValues(values)
run_id = NodeId(0, iens)
data_node.save(target_fs, run_id)
target_fs.fsync()
state_map = target_fs.getStateMap()
state_map[iens] = RealizationStateEnum.STATE_INITIALIZED
