class ForwardLoadContext(BaseCClass):
TYPE_NAME = "forward_load_context"
_alloc = EnkfPrototype("void* forward_load_context_alloc( run_arg , bool , ecl_config , char* , stringlist )" , bind = False)
_select_step = EnkfPrototype("void forward_load_context_select_step( forward_load_context , int )")
_get_step = EnkfPrototype("int forward_load_context_get_load_step( forward_load_context)")
_free = EnkfPrototype("void forward_load_context_free( forward_load_context)")
def __init__(self , run_arg = None , load_summary = False , ecl_config = None , ecl_base = None , messages = None , report_step = None):
c_ptr = self._alloc(run_arg , load_summary , ecl_config , ecl_base , messages)
super(ForwardLoadContext, self).__init__(c_ptr)
if not report_step is None:
self.selectStep( report_step )
def getLoadStep( self ):
return self._get_step( )
def selectStep(self , report_step):
self._select_step( report_step)
def free(self):
self._free( )
class RunArg(BaseCClass):
TYPE_NAME = "run_arg"
_alloc_ENSEMBLE_EXPERIMENT = EnkfPrototype(
"run_arg_obj run_arg_alloc_ENSEMBLE_EXPERIMENT(enkf_fs , int, int, char*)",
bind=False)
_free = EnkfPrototype("void run_arg_free(run_arg)")
_get_queue_index = EnkfPrototype("int run_arg_get_queue_index(run_arg)")
_is_submitted = EnkfPrototype("bool run_arg_is_submitted(run_arg)")
def __init__(self):
raise NotImplementedError("Cannot instantiat RunArg directly!")
@classmethod
def createEnsembleExperimentRunArg(cls, fs, iens, runpath, iter=0):
return cls._alloc_ENSEMBLE_EXPERIMENT(fs, iens, iter, runpath)
def free(self):
self._free()
def getQueueIndex(self):
return self._get_queue_index()
def isSubmitted(self):
return self._is_submitted()
def __repr__(self):
su = 'submitted' if self.isSubmitted() else 'not submitted'
qi = self.getQueueIndex()
return 'RunArg(queue_index = %d, %s) %s' % (qi, su, self._ad_str())
class ErtTemplates(BaseCClass):
TYPE_NAME = "ert_templates"
_free = EnkfPrototype("void ert_templates_free( ert_templates )")
_alloc_list = EnkfPrototype(
"stringlist_ref ert_templates_alloc_list(ert_templates)")
_get_template = EnkfPrototype(
"ert_template_ref ert_templates_get_template(ert_templates, char*)")
_clear = EnkfPrototype("void ert_templates_clear(ert_templates)")
_add_template = EnkfPrototype(
"ert_template_ref ert_templates_add_template(ert_templates, char*, char*, char*, char*)"
)
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def getTemplateNames(self):
""" @rtype: StringList """
return self._alloc_list().setParent(self)
def clear(self):
self._clear()
def get_template(self, key):
""" @rtype: ErtTemplate """
return self._get_template(key).setParent(self)
def add_template(self, key, template_file, target_file, arg_string):
""" @rtype: ErtTemplate """
return self._add_template(key, template_file, target_file,
arg_string).setParent(self)
def free(self):
self._free()
class ErtTemplate(BaseCClass):
TYPE_NAME = "ert_template"
_free = EnkfPrototype("void ert_template_free( ert_template )")
_get_template_file = EnkfPrototype("char* ert_template_get_template_file(ert_template)")
_get_target_file = EnkfPrototype("char* ert_template_get_target_file(ert_template)")
_get_args_as_string = EnkfPrototype("char* ert_template_get_args_as_string(ert_template)")
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def get_template_file(self):
""" @rtype: str """
return self._get_template_file()
def get_target_file(self):
""" @rtype: str """
return self._get_target_file()
def get_args_as_string(self):
""" @rtype: str """
return self._get_args_as_string()
def free(self):
self._free()
class Field(BaseCClass):
TYPE_NAME = "field"
_free = EnkfPrototype("void field_free( field )")
_ijk_get_double = EnkfPrototype(
"double field_ijk_get_double(field, int, int, int)")
_export = EnkfPrototype(
"void field_export(field, char* , fortio , enkf_field_file_format_enum , bool , char*)"
)
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def ijk_get_double(self, i, j, k):
return self._ijk_get_double(i, j, k)
def export(self, filename, file_type=None, init_file=None):
output_transform = False
if file_type is None:
try:
file_type = FieldConfig.exportFormat(filename)
except ValueError:
sys.stderr.write(
"Sorry - could not infer output format from filename:%s\n"
% filename)
return False
self._export(filename, None, file_type, output_transform, init_file)
return True
def free(self):
self._free()
class EnsemblePlotDataVector(BaseCClass):
TYPE_NAME = "ensemble_plot_data_vector"
_size = EnkfPrototype(
"int enkf_plot_tvector_size(ensemble_plot_data_vector)")
_get_value = EnkfPrototype(
"double enkf_plot_tvector_iget_value(ensemble_plot_data_vector, int)")
_get_time = EnkfPrototype(
"time_t enkf_plot_tvector_iget_time(ensemble_plot_data_vector, int)")
_is_active = EnkfPrototype(
"bool enkf_plot_tvector_iget_active(ensemble_plot_data_vector, int)")
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def __len__(self):
""" @rtype: int """
return self._size()
def getValue(self, index):
""" @rtype: float """
return self._get_value(index)
def getTime(self, index):
""" @rtype: CTime """
return self._get_time(index)
def isActive(self, index):
""" @rtype: bool """
return self._is_active(index)
def __repr__(self):
return 'EnsemblePlotDataVector(size = %d) %s' % (len(self),
self._ad_str())
class EnsemblePlotData(BaseCClass):
TYPE_NAME = "ensemble_plot_data"
_alloc = EnkfPrototype("void* enkf_plot_data_alloc(enkf_config_node)",
bind=False)
_load = EnkfPrototype(
"void enkf_plot_data_load(ensemble_plot_data, enkf_fs, char*, bool_vector)"
)
_size = EnkfPrototype("int enkf_plot_data_get_size(ensemble_plot_data)")
_get = EnkfPrototype(
"ensemble_plot_data_vector_ref enkf_plot_data_iget(ensemble_plot_data, int)"
)
_free = EnkfPrototype("void enkf_plot_data_free(ensemble_plot_data)")
def __init__(self,
ensemble_config_node,
file_system=None,
user_index=None,
input_mask=None):
assert isinstance(ensemble_config_node, EnkfConfigNode)
c_pointer = self._alloc(ensemble_config_node)
super(EnsemblePlotData, self).__init__(c_pointer)
if not file_system is None:
self.load(file_system, user_index, input_mask)
def load(self, file_system, user_index=None, input_mask=None):
assert isinstance(file_system, EnkfFs)
if not input_mask is None:
assert isinstance(input_mask, BoolVector)
self._load(file_system, user_index, input_mask)
def __len__(self):
""" @rtype: int """
return self._size()
def __getitem__(self, index):
""" @rtype: EnsemblePlotDataVector """
return self._get(index)
def __iter__(self):
cur = 0
while cur < len(self):
yield self[cur]
cur += 1
def free(self):
self._free()
def __repr__(self):
return 'EnsemblePlotData(size = %d) %s' % (len(self), self._ad_str())
class HookManager(BaseCClass):
TYPE_NAME = "hook_manager"
_get_runpath_list_file = EnkfPrototype("char* hook_manager_get_runpath_list_file(hook_manager)")
_get_runpath_list = EnkfPrototype("runpath_list_ref hook_manager_get_runpath_list(hook_manager)")
_iget_hook_workflow = EnkfPrototype("hook_workflow_ref hook_manager_iget_hook_workflow(hook_manager, int)")
_size = EnkfPrototype("int hook_manager_get_size(hook_manager)")
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def __len__(self):
""" @rtype: int """
return self._size()
def __repr__(self):
return 'HookManager(size = %d) %s' % (len(self), self._ad_str())
def __getitem__(self, index):
""" @rtype: Hook workflow """
assert isinstance(index, int)
if index < 0:
index += len(self)
if 0 <= index < len(self):
return self._iget_hook_workflow(index)
else:
raise IndexError("Invalid index. Valid range: [0, %d)." % len(self))
def checkRunpathListFile(self):
""" @rtype: bool """
runpath_list_file = self._get_runpath_list_file()
if not os.path.exists(runpath_list_file):
sys.stderr.write("** Warning: the file: %s with a list of runpath directories was not found - hook workflow will probably fail.\n" % runpath_list_file)
def getRunpathList(self):
""" @rtype: RunpathList """
return self._get_runpath_list()
def runWorkflows(self , run_time , ert_self):
workflow_list = ert_self.getWorkflowList()
for hook_workflow in self:
if (hook_workflow.getRunMode() is not run_time):
continue
workflow = hook_workflow.getWorkflow()
workflow.run(ert_self, context=workflow_list.getContext())
class ESUpdate(BaseCClass):
TYPE_NAME="es_update"
_smoother_update = EnkfPrototype("bool enkf_main_smoother_update(es_update, enkf_fs, enkf_fs)")
def __init__(self , ert):
assert isinstance(ert , BaseCClass)
super(ESUpdate, self).__init__(ert.from_param(ert).value , parent=ert , is_reference=True)
self.ert = ert
self.analysis_config = self.ert.analysisConfig( )
def hasModule(self, name):
"""
Will check if we have analysis module @name.
"""
return self.analysis_config.hasModule( name )
def getModule(self,name):
if self.hasModule( name ):
self.analysis_config.getModule( name )
else:
raise KeyError("No such module:%s " % name)
def setGlobalStdScaling(self , weight):
self.analysis_config.setGlobalStdScaling( weight )
def smootherUpdate( self , data_fs , target_fs):
return self._smoother_update(data_fs , target_fs )
class EnkfSimulationRunner(BaseCClass):
TYPE_NAME = "enkf_simulation_runner"
_create_run_path = EnkfPrototype(
"bool enkf_main_create_run_path(enkf_simulation_runner, bool_vector, int)"
)
_run_simple_step = EnkfPrototype(
"int enkf_main_run_simple_step(enkf_simulation_runner, bool_vector, enkf_init_mode_enum, int)"
)
def __init__(self, enkf_main):
assert isinstance(enkf_main, BaseCClass)
super(EnkfSimulationRunner,
self).__init__(enkf_main.from_param(enkf_main).value,
parent=enkf_main,
is_reference=True)
self.ert = enkf_main
""":type: ert.enkf.EnKFMain """
def runSimpleStep(self, active_realization_mask, initialization_mode,
iter_nr):
""" @rtype: int """
assert isinstance(active_realization_mask, BoolVector)
assert isinstance(initialization_mode, EnkfInitModeEnum)
return self._run_simple_step(active_realization_mask,
initialization_mode, iter_nr)
def createRunPath(self, active_realization_mask, iter_nr):
""" @rtype: bool """
assert isinstance(active_realization_mask, BoolVector)
return self._create_run_path(active_realization_mask, iter_nr)
def runEnsembleExperiment(self, active_realization_mask=None):
""" @rtype: int """
if active_realization_mask is None:
count = self.ert.getEnsembleSize()
active_realization_mask = BoolVector(default_value=True,
initial_size=count)
iter_nr = 0
return self.runSimpleStep(active_realization_mask,
EnkfInitModeEnum.INIT_CONDITIONAL, iter_nr)
def runWorkflows(self, runtime):
""":type ert.enkf.enum.HookRuntimeEnum"""
hook_manager = self.ert.getHookManager()
hook_manager.runWorkflows(runtime, self.ert)
class ObsBlock(BaseCClass):
TYPE_NAME = "obs_block"
_alloc = EnkfPrototype("void* obs_block_alloc(char*, int, matrix, bool, double)", bind = False)
_free = EnkfPrototype("void obs_block_free(obs_block)")
_total_size = EnkfPrototype("int obs_block_get_size( obs_block )")
_active_size = EnkfPrototype("int obs_block_get_active_size( obs_block )")
_iset = EnkfPrototype("void obs_block_iset( obs_block , int , double , double)")
_iget_value = EnkfPrototype("double obs_block_iget_value( obs_block , int)")
_iget_std = EnkfPrototype("double obs_block_iget_std( obs_block , int)")
def __init__(self , obs_key , obs_size , global_std_scaling=1.0):
error_covar = None
error_covar_owner = False
c_pointer = self._alloc(obs_key , obs_size , error_covar , error_covar_owner, global_std_scaling)
super(ObsBlock, self).__init__(c_pointer)
def totalSize(self):
return self._total_size()
def activeSize(self):
return self.active()
def active(self):
return self._active_size()
def __len__(self):
"""Returns the total size"""
return self.totalSize()
def __setitem__(self , index , value):
if len(value) != 2:
raise TypeError("The value argument must be a two element tuple: (value , std)")
d, std = value
if isinstance(index , int):
if index < 0:
index += len(self)
if 0 <= index < len(self):
self._iset(index, d, std)
else:
raise IndexError("Invalid index: %d. Valid range: [0,%d)" % (index , len(self)))
else:
raise TypeError("The index item must be integer, not %s." % str(type(index)))
def __getitem__(self , index):
if isinstance(index , int):
if index < 0:
index += len(self)
if 0 <= index < len(self):
value = self._iget_value(index)
std = self._iget_std(index)
return (value,std)
else:
raise IndexError("Invalid index:%d - valid range: [0,%d)" % (index , len(self)))
else:
raise TypeError("The index item must be integer, not %s." % str(type(index)))
def free(self):
self._free()
class ActiveList(BaseCClass):
TYPE_NAME = "active_list"
_alloc = EnkfPrototype("void* active_list_alloc()", bind=False)
_free = EnkfPrototype("void active_list_free(active_list)")
_add_index = EnkfPrototype(
"void active_list_add_index(active_list , int)")
_asize = EnkfPrototype(
"int active_list_get_active_size(active_list, int)")
_get_mode = EnkfPrototype(
"active_mode_enum active_list_get_mode(active_list)")
def __init__(self):
c_ptr = self._alloc()
super(ActiveList, self).__init__(c_ptr)
def getMode(self):
return self._get_mode()
def addActiveIndex(self, index):
self._add_index(index)
def getActiveSize(self, default_value):
"""In mode PARTLY_ACTIVE, we return the size of the active set; In mode
INACTIVE 0 is returned and if the mode is ALL_ACTIVE, the input
default_value is returned.
"""
mode = self.getMode()
if mode == ActiveMode.PARTLY_ACTIVE:
return self._asize(0)
if mode == ActiveMode.INACTIVE:
return 0
return default_value
def free(self):
self._free()
def __repr__(self):
size = ''
if self.getMode() == ActiveMode.PARTLY_ACTIVE:
size = ', active_size = %d' % self._asize(0)
cnt = 'mode = %s%s' % (self.getMode(), size)
return self._create_repr(cnt)
class ErtLog(object):
_init = EnkfPrototype("void ert_log_init_log(int, char*, bool)",
bind=False)
_write_log = EnkfPrototype("void ert_log_add_message_py(int, char*)",
bind=False)
_get_filename = EnkfPrototype("char* ert_log_get_filename()", bind=False)
@classmethod
def init(cls, log_level, log_filename, verbose):
cls._init(log_level, log_filename, verbose)
@classmethod
def log(cls, log_level, message):
cls._write_log(log_level, message)
@classmethod
def getFilename(cls):
""" @rtype: string """
return cls._get_filename()
class SummaryKeySet(BaseCClass):
TYPE_NAME = "summary_key_set"
_alloc = EnkfPrototype("void* summary_key_set_alloc()", bind = False)
_alloc_from_file = EnkfPrototype("void* summary_key_set_alloc_from_file(char*, bool)", bind = False)
_free = EnkfPrototype("void summary_key_set_free(summary_key_set)")
_size = EnkfPrototype("int summary_key_set_get_size(summary_key_set)")
_add_key = EnkfPrototype("bool summary_key_set_add_summary_key(summary_key_set, char*)")
_has_key = EnkfPrototype("bool summary_key_set_has_summary_key(summary_key_set, char*)")
_keys = EnkfPrototype("stringlist_obj summary_key_set_alloc_keys(summary_key_set)")
_is_read_only = EnkfPrototype("bool summary_key_set_is_read_only(summary_key_set)")
_fwrite = EnkfPrototype("void summary_key_set_fwrite(summary_key_set, char*)")
def __init__(self, filename=None, read_only=False):
if filename is None:
c_ptr = self._alloc()
else:
c_ptr = self._alloc_from_file(filename, read_only)
super(SummaryKeySet, self).__init__(c_ptr)
def addSummaryKey(self, key):
assert isinstance(key, str)
return self._add_key(key)
def __len__(self):
return self._size()
def __contains__(self, key):
return self._has_key(key)
def keys(self):
""" @rtype: StringList """
return self._keys()
def isReadOnly(self):
""" @rtype: bool """
return self._is_read_only()
def writeToFile(self, filename):
assert isinstance(filename, str)
self._fwrite(filename)
def free(self):
self._free()
class CustomKWConfigSet(BaseCClass):
TYPE_NAME = "custom_kw_config_set"
_alloc = EnkfPrototype("void* custom_kw_config_set_alloc()", bind=False)
_alloc_from_file = EnkfPrototype(
"void* custom_kw_config_set_alloc_from_file(char*)", bind=False)
_free = EnkfPrototype(
"void custom_kw_config_set_free(custom_kw_config_set)")
_reset = EnkfPrototype(
"void custom_kw_config_set_reset(custom_kw_config_set)")
_add_config = EnkfPrototype(
"void custom_kw_config_set_add_config(custom_kw_config_set, custom_kw_config)"
)
_update_config = EnkfPrototype(
"void custom_kw_config_set_update_config(custom_kw_config_set, custom_kw_config)"
)
_fwrite = EnkfPrototype(
"void custom_kw_config_set_fwrite(custom_kw_config_set, char*)")
_get_keys = EnkfPrototype(
"stringlist_obj custom_kw_config_set_get_keys_alloc(custom_kw_config_set)"
)
def __init__(self, filename=None):
if filename is None:
c_ptr = self._alloc()
else:
c_ptr = self._alloc_from_file(filename)
super(CustomKWConfigSet, self).__init__(c_ptr)
def addConfig(self, config):
""" @type config: CustomKWConfig """
assert isinstance(config, CustomKWConfig)
self._add_config(config)
def getStoredConfigKeys(self):
""" @rtype: StringList """
return self._get_keys()
def updateConfig(self, config):
""" @type config: CustomKWConfig """
self._update_config(config)
def fwrite(self, filename):
""" @type filename: str """
self._fwrite(filename)
def reset(self):
self._reset()
def free(self):
self._free()
class PcaPlotVector(BaseCClass):
TYPE_NAME = "pca_plot_vector"
_alloc = EnkfPrototype("void* pca_plot_vector_alloc(int, matrix, matrix)",
bind=False)
_size = EnkfPrototype("int pca_plot_vector_get_size(pca_plot_vector)")
_get = EnkfPrototype(
"double pca_plot_vector_iget_sim_value(pca_plot_vector, int)")
_get_obs = EnkfPrototype(
"double pca_plot_vector_get_obs_value(pca_plot_vector)")
_get_singular_value = EnkfPrototype(
"double pca_plot_vector_get_singular_value(pca_plot_vector)")
_free = EnkfPrototype("void pca_plot_vector_free(pca_plot_vector)")
def __init__(self, component, principal_component_matrix,
observation_principal_component_matrix):
assert isinstance(component, int)
assert isinstance(principal_component_matrix, Matrix)
assert isinstance(observation_principal_component_matrix, Matrix)
c_pointer = self._alloc(component, principal_component_matrix,
observation_principal_component_matrix)
super(PcaPlotVector, self).__init__(c_pointer)
def __len__(self):
""" @rtype: int """
return self._size()
def __getitem__(self, index):
"""
@type index: int
@rtype: float
"""
assert isinstance(index, int)
return self._get(index)
def __iter__(self):
cur = 0
while cur < len(self):
yield self[cur]
cur += 1
def getObservation(self):
""" @rtype: float """
return self._get_obs()
def getSingularValue(self):
""" @rtype: float """
return self._get_singular_value()
def free(self):
self._free()
def __repr__(self):
si = len(self)
ob = self.getObservation()
sv = self.getSingularValue()
ad = self._ad_str()
fmt = 'PcaPlotVector(size = %d, observation = %f, singular = %f) %s'
return fmt % (si, ob, sv, ad)
class ErtRunContext(BaseCClass):
TYPE_NAME = "ert_run_context"
_alloc_runpath_list = EnkfPrototype(
"stringlist_obj ert_run_context_alloc_runpath_list(bool_vector, path_fmt, subst_list, int)",
bind=False)
_alloc_runpath = EnkfPrototype(
"char* ert_run_context_alloc_runpath(int, path_fmt, subst_list, int)",
bind=False)
_get_size = EnkfPrototype(
"int ert_run_context_get_size( ert_run_context )")
_free = EnkfPrototype("void ert_run_context_free( ert_run_context )")
_iget = EnkfPrototype(
"run_arg_ref ert_run_context_iget_arg( ert_run_context , int)")
_iens_get = EnkfPrototype(
"run_arg_ref ert_run_context_iens_get_arg( ert_run_context , int)")
def __init__(self):
raise NotImplementedError("Class can not be instantiated directly!")
def __len__(self):
return self._get_size()
def __getitem__(self, index):
if isinstance(index, int):
if 0 <= index < len(self):
run_arg = self._iget(index)
run_arg.setParent(self)
return run_arg
else:
raise IndexError("Index:%d invalid. Legal range: [0,%d)" %
(index, len(self)))
else:
raise TypeError("Invalid type - expetected integer")
def iensGet(self, iens):
run_arg = self._iens_get(iens)
if run_arg is not None:
run_arg.setParent(self)
return run_arg
else:
raise ValueError(
"Run context does not have run argument for iens:%d" % iens)
def free(self):
self._free()
def __repr__(self):
return 'ErtRunContext(size = %d) %s' % (len(self), self._ad_str())
@classmethod
def createRunpathList(cls, mask, runpath_fmt, subst_list, iter=0):
""" @rtype: ert.util.stringlist.StringList """
return cls._alloc_runpath_list(mask, runpath_fmt, subst_list, iter)
@classmethod
def createRunpath(cls, iens, runpath_fmt, subst_list, iter=0):
""" @rtype: str """
return cls._alloc_runpath(iens, runpath_fmt, subst_list, iter)
class GenData(BaseCClass):
TYPE_NAME = "gen_data"
_alloc = EnkfPrototype("void* gen_data_alloc()", bind=False)
_free = EnkfPrototype("void gen_data_free(gen_data)")
_size = EnkfPrototype("int gen_data_get_size(gen_data)")
_iget = EnkfPrototype("double gen_data_iget_double(gen_data , int)")
_export = EnkfPrototype(
"void gen_data_export(gen_data , char*, gen_data_file_format_type, fortio)"
)
_export_data = EnkfPrototype(
"void gen_data_export_data(gen_data , double_vector)")
def __init__(self):
c_ptr = self._alloc()
if c_ptr:
super(GenData, self).__init__(c_ptr)
else:
raise ValueError('Unable to construct GenData object.')
def __len__(self):
""" @rtype: int """
return self._size()
def free(self):
self._free()
def __repr__(self):
return 'GenData(len = %d) %s' % (len(self), self._ad_str())
def export(self, file_name, file_format_type, fortio):
"""
@type: str
@type: GenDataFileType
@type: FortIO
"""
self._export(file_name, file_format_type, fortio)
def getData(self):
data = DoubleVector()
self._export_data(data)
return data
def __getitem__(self, idx):
"""Returns an item, or a list if idx is a slice.
Note: When idx is a slice it does not return a new GenData!
"""
ls = len(self)
if isinstance(idx, int):
if idx < 0:
idx += ls
if 0 <= idx < ls:
return self._iget(idx)
raise IndexError('List index out of range.')
if isinstance(idx, slice):
vec = self.getData()
return [vec[i] for i in range(*idx.indices(ls))]
raise TypeError('List indices must be integers, not %s.' %
str(type(idx)))
class EnkfLinalg(BaseCClass):
TYPE_NAME = "EnkfLinalg"
_get_PC = EnkfPrototype("void enkf_linalg_get_PC(matrix, matrix, double, int, matrix, matrix, double_vector)", bind = False)
@classmethod
def calculatePrincipalComponents(cls, S0, D_obs, truncation, ncomp, PC, PC_obs, singular_values):
assert isinstance(S0, Matrix)
assert isinstance(D_obs, Matrix)
assert isinstance(truncation, (float, int))
assert isinstance(ncomp, int)
assert isinstance(PC, Matrix)
assert isinstance(PC_obs, Matrix)
assert isinstance(singular_values , DoubleVector)
cls._get_PC(S0, D_obs, truncation, ncomp, PC, PC_obs , singular_values)
class LocalUpdateStep(BaseCClass):
TYPE_NAME = "local_updatestep"
_alloc = EnkfPrototype("void local_updatestep_alloc(char*)", bind=False)
_size = EnkfPrototype(
"int local_updatestep_get_num_ministep(local_updatestep)")
_iget_ministep = EnkfPrototype(
"local_ministep_ref local_updatestep_iget_ministep(local_updatestep, int)"
)
_free = EnkfPrototype("void local_updatestep_free(local_updatestep)")
_attach_ministep = EnkfPrototype(
"void local_updatestep_add_ministep(local_updatestep, local_ministep)"
)
_name = EnkfPrototype("char* local_updatestep_get_name(local_updatestep)")
def __init__(self, updatestep_key):
raise NotImplementedError("Class can not be instantiated directly!")
def __len__(self):
""" @rtype: int """
return self._size()
def __getitem__(self, index):
""" @rtype: LocalMinistep """
if not isinstance(index, int):
raise TypeError('Keys must be ints, not %s' % str(type(index)))
if index < 0:
index += len(self)
if 0 <= index < len(self):
return self._iget_ministep(index)
else:
raise IndexError('Invalid index, valid range: [0, %d)' % len(self))
def attachMinistep(self, ministep):
assert isinstance(ministep, LocalMinistep)
self._attach_ministep(ministep)
def name(self):
return self._name()
def getName(self):
""" @rtype: str """
return self.name()
def free(self):
self._free(self)
class SummaryKeyMatcher(BaseCClass):
TYPE_NAME = "summary_key_matcher"
_alloc = EnkfPrototype("void* summary_key_matcher_alloc()", bind = False)
_free = EnkfPrototype("void summary_key_matcher_free(summary_key_matcher)")
_size = EnkfPrototype("int summary_key_matcher_get_size(summary_key_matcher)")
_add_key = EnkfPrototype("void summary_key_matcher_add_summary_key(summary_key_matcher, char*)")
_match_key = EnkfPrototype("bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)")
_keys = EnkfPrototype("stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)")
_is_required = EnkfPrototype("bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)")
def __init__(self):
c_ptr = self._alloc()
super(SummaryKeyMatcher, self).__init__(c_ptr)
def addSummaryKey(self, key):
assert isinstance(key, str)
return self._add_key(key)
def __len__(self):
return self._size()
def __contains__(self, key):
return self._match_key(key)
def isRequired(self, key):
""" @rtype: bool """
return self._is_required(key)
def keys(self):
""" @rtype: StringList """
return self._keys()
def free(self):
self._free()
class EnsemblePlotGenData(BaseCClass):
TYPE_NAME = "ensemble_plot_gen_data"
_alloc = EnkfPrototype("void* enkf_plot_gendata_alloc(enkf_config_node)",
bind=False)
_size = EnkfPrototype(
"int enkf_plot_gendata_get_size(ensemble_plot_gen_data)")
_load = EnkfPrototype(
"void enkf_plot_gendata_load(ensemble_plot_gen_data, enkf_fs, int, bool_vector)"
)
_get = EnkfPrototype(
"ensemble_plot_gen_data_vector_ref enkf_plot_gendata_iget(ensemble_plot_gen_data, int)"
)
_min_values = EnkfPrototype(
"double_vector_ref enkf_plot_gendata_get_min_values(ensemble_plot_gen_data)"
)
_max_values = EnkfPrototype(
"double_vector_ref enkf_plot_gendata_get_max_values(ensemble_plot_gen_data)"
)
_free = EnkfPrototype(
"void enkf_plot_gendata_free(ensemble_plot_gen_data)")
def __init__(self,
ensemble_config_node,
file_system,
report_step,
input_mask=None):
assert isinstance(ensemble_config_node, EnkfConfigNode)
assert ensemble_config_node.getImplementationType(
) == ErtImplType.GEN_DATA
c_ptr = self._alloc(ensemble_config_node)
if c_ptr:
super(EnsemblePlotGenData, self).__init__(c_ptr)
else:
raise ValueError(
'Unable to construct EnsemplePlotGenData from given config node!'
)
self.__load(file_system, report_step, input_mask)
def __load(self, file_system, report_step, input_mask=None):
assert isinstance(file_system, EnkfFs)
if not input_mask is None:
assert isinstance(input_mask, BoolVector)
self._load(file_system, report_step, input_mask)
def __len__(self):
""" @rtype: int """
return self._size()
def __getitem__(self, index):
""" @rtype: EnsemblePlotGenDataVector """
return self._get(index)
def __iter__(self):
cur = 0
while cur < len(self):
yield self[cur]
cur += 1
def getMaxValues(self):
""" @rtype: DoubleVector """
return self._max_values().setParent(self)
def getMinValues(self):
""" @rtype: DoubleVector """
return self._min_values().setParent(self)
def free(self):
self._free()
def __repr__(self):
return 'EnsemblePlotGenData(size = %d) %s' % (len(self),
self._ad_str())
