import sys from types import IntType, SliceType from ert.cwrap import CWrapper, CFILE, BaseCClass from ert.util import UTIL_LIB class PermutationVector(BaseCClass): def __init__(self): raise NotImplementedError("Class can not be instantiated directly!") def free(self): PermutationVector.cNamespace().free(self) CWrapper.registerObjectType("permutation_vector", PermutationVector) cwrapper = CWrapper(UTIL_LIB) PermutationVector.cNamespace().free = cwrapper.prototype( "void util_safe_free(permutation_vector)") # TVector takes advantage of the fact that self.cNamespace belongs to the inheriting class class VectorTemplate(BaseCClass): @classmethod def strided_copy(cls, obj, slice_range): """ Will create a new copy according to @slice. Mainly a support function to support slice based lookup like
def load(self, config_file): if not os.path.isfile(config_file): raise IOError("The observation config file:%s does not exist" % config_file) return EnkfObs.cNamespace().load(self, config_file) def clear(self): EnkfObs.cNamespace().clear(self) def free(self): EnkfObs.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_obs", EnkfObs) EnkfObs.cNamespace().alloc = cwrapper.prototype( "c_void_p enkf_obs_alloc( history , time_map , ecl_grid , ecl_sum , ens_config )" ) EnkfObs.cNamespace().free = cwrapper.prototype( "void enkf_obs_free( enkf_obs )") EnkfObs.cNamespace().get_size = cwrapper.prototype( "int enkf_obs_get_size( enkf_obs )") EnkfObs.cNamespace().load = cwrapper.prototype( "bool enkf_obs_load( enkf_obs , char*)") EnkfObs.cNamespace().clear = cwrapper.prototype( "void enkf_obs_clear( enkf_obs )") EnkfObs.cNamespace().alloc_typed_keylist = cwrapper.prototype( "stringlist_obj enkf_obs_alloc_typed_keylist(enkf_obs, enkf_obs_impl_type)" )
@type iteration_number: int @type runpath: int @type basename: int """ RunpathList.cNamespace().add(self, realization_number, iteration_number, runpath, basename) def clear(self): RunpathList.cNamespace().clear(self) def free(self): RunpathList.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("runpath_list", RunpathList) RunpathList.cNamespace().free = cwrapper.prototype( "void runpath_list_free(runpath_list)") RunpathList.cNamespace().add = cwrapper.prototype( "void runpath_list_add(runpath_list, int, int, char*, char*)") RunpathList.cNamespace().clear = cwrapper.prototype( "void runpath_list_clear(runpath_list)") RunpathList.cNamespace().size = cwrapper.prototype( "int runpath_list_size(runpath_list)") RunpathList.cNamespace().iens = cwrapper.prototype( "int runpath_list_iget_iens(runpath_list, int)") RunpathList.cNamespace().iteration = cwrapper.prototype( "int runpath_list_iget_iter(runpath_list, int)")
def get_ny(self): return FieldConfig.cNamespace().get_ny(self) def get_nz(self): return FieldConfig.cNamespace().get_nz(self) def ijk_active(self, i, j, k): return FieldConfig.cNamespace().ijk_active(self, i, j, k) def free(self): FieldConfig.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("field_config", FieldConfig) FieldConfig.cNamespace().alloc = cwrapper.prototype("c_void_p field_config_alloc_empty(char* , ecl_grid , c_void_p , bool)") FieldConfig.cNamespace().free = cwrapper.prototype("void field_config_free( field_config )") FieldConfig.cNamespace().get_type = cwrapper.prototype("int field_config_get_type(field_config)") FieldConfig.cNamespace().get_truncation_mode = cwrapper.prototype("int field_config_get_truncation_mode(field_config)") FieldConfig.cNamespace().get_truncation_min = cwrapper.prototype("double field_config_get_truncation_min(field_config)") FieldConfig.cNamespace().get_truncation_max = cwrapper.prototype("double field_config_get_truncation_max(field_config)") FieldConfig.cNamespace().get_init_transform_name = cwrapper.prototype("char* field_config_get_init_transform_name(field_config)") FieldConfig.cNamespace().get_output_transform_name = cwrapper.prototype("char* field_config_get_output_transform_name(field_config)") FieldConfig.cNamespace().ijk_active = cwrapper.prototype("bool field_config_ijk_active(field_config, int, int, int)") FieldConfig.cNamespace().get_nx = cwrapper.prototype("int field_config_get_nx(field_config)") FieldConfig.cNamespace().get_ny = cwrapper.prototype("int field_config_get_ny(field_config)") FieldConfig.cNamespace().get_nz = cwrapper.prototype("int field_config_get_nz(field_config)") FieldConfig.cNamespace().get_grid = cwrapper.prototype("c_void_p field_config_get_grid(field_config)") #todo: fix return type
if isinstance(value, float): DoubleHash.cNamespace().insert_double(self, key, value) else: raise ValueError("DoubleHash does not support type: %s" % value.__class__) def __getitem__(self, key): if key in self: return DoubleHash.cNamespace().get_double(self, key) else: raise KeyError("Hash does not have key: %s" % key) cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("hash", Hash) # c_void_p type CWrapper.registerObjectType("integer_hash", IntegerHash) CWrapper.registerObjectType("string_hash", StringHash) CWrapper.registerObjectType("double_hash", DoubleHash) Hash.cNamespace().alloc = cwrapper.prototype("long hash_alloc()") Hash.cNamespace().free = cwrapper.prototype("void hash_free(hash)") Hash.cNamespace().size = cwrapper.prototype("int hash_get_size(hash)") Hash.cNamespace().keys = cwrapper.prototype("stringlist_obj hash_alloc_stringlist(hash)") Hash.cNamespace().has_key = cwrapper.prototype("bool hash_has_key(hash, char*)") Hash.cNamespace().get = cwrapper.prototype("c_void_p hash_get(hash, char*)") IntegerHash.cNamespace().get_int = cwrapper.prototype("int hash_get_int(hash, char*)") DoubleHash.cNamespace().get_double = cwrapper.prototype("double hash_get_double(hash, char*)") StringHash.cNamespace().get_string = cwrapper.prototype("char* hash_get_string(hash, char*)")
elif implementation_type == ErtImplType.GEN_KW: return self.getKeywordModelConfig() elif implementation_type == ErtImplType.CUSTOM_KW: return self.getCustomKeywordModelConfig() elif implementation_type == ErtImplType.SUMMARY: return SummaryConfig.createCReference(self.getPointerReference(), parent=self) else: print("[EnkfConfigNode::getModelConfig()] Unhandled implementation model type: %i" % implementation_type) # raise NotImplementedError("Unknown model type: %i" % type) def getKey(self): return EnkfConfigNode.cNamespace().get_key( self ) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_config_node", EnkfConfigNode) EnkfConfigNode.cNamespace().free = cwrapper.prototype("void enkf_config_node_free(enkf_config_node)") EnkfConfigNode.cNamespace().get_ref = cwrapper.prototype("c_void_p enkf_config_node_get_ref(enkf_config_node)") #todo: fix return type EnkfConfigNode.cNamespace().get_impl_type = cwrapper.prototype("ert_impl_type_enum enkf_config_node_get_impl_type(enkf_config_node)") EnkfConfigNode.cNamespace().get_enkf_outfile = cwrapper.prototype("char* enkf_config_node_get_enkf_outfile(enkf_config_node)") EnkfConfigNode.cNamespace().get_min_std_file = cwrapper.prototype("char* enkf_config_node_get_min_std_file(enkf_config_node)") EnkfConfigNode.cNamespace().get_enkf_infile = cwrapper.prototype("char* enkf_config_node_get_enkf_infile(enkf_config_node)") EnkfConfigNode.cNamespace().get_init_file_fmt = cwrapper.prototype("char* enkf_config_node_get_init_file_fmt(enkf_config_node)") EnkfConfigNode.cNamespace().get_var_type = cwrapper.prototype("enkf_var_type_enum enkf_config_node_get_var_type(enkf_config_node)") #todo: fix return type as enum EnkfConfigNode.cNamespace().get_key = cwrapper.prototype("char* enkf_config_node_get_key(enkf_config_node)") EnkfConfigNode.cNamespace().get_obs_keys = cwrapper.prototype("stringlist_ref enkf_config_node_get_obs_keys(enkf_config_node)") EnkfConfigNode.cNamespace().alloc_summary_node = cwrapper.prototype("enkf_config_node_obj enkf_config_node_alloc_summary(char*, load_fail_type)") EnkfConfigNode.cNamespace().alloc_field_node = cwrapper.prototype("enkf_config_node_obj enkf_config_node_alloc_field(char*, ecl_grid, c_void_p, bool)") EnkfConfigNode.cNamespace().update_state_field = cwrapper.prototype("void enkf_config_node_update_state_field(enkf_config_node, enkf_truncation_type_enum, double, double)")
elif implementation_type == ErtImplType.GEN_KW: return self.getKeywordModelConfig() elif implementation_type == ErtImplType.CUSTOM_KW: return self.getCustomKeywordModelConfig() elif implementation_type == ErtImplType.SUMMARY: return SummaryConfig.createCReference(self.getPointerReference(), parent=self) else: print( "[EnkfConfigNode::getModelConfig()] Unhandled implementation model type: %i" % implementation_type) # raise NotImplementedError("Unknown model type: %i" % type) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_config_node", EnkfConfigNode) EnkfConfigNode.cNamespace().free = cwrapper.prototype( "void enkf_config_node_free(enkf_config_node)") EnkfConfigNode.cNamespace().get_ref = cwrapper.prototype( "c_void_p enkf_config_node_get_ref(enkf_config_node)" ) #todo: fix return type EnkfConfigNode.cNamespace().get_impl_type = cwrapper.prototype( "ert_impl_type_enum enkf_config_node_get_impl_type(enkf_config_node)") EnkfConfigNode.cNamespace().get_enkf_outfile = cwrapper.prototype( "char* enkf_config_node_get_enkf_outfile(enkf_config_node)") EnkfConfigNode.cNamespace().get_min_std_file = cwrapper.prototype( "char* enkf_config_node_get_min_std_file(enkf_config_node)") EnkfConfigNode.cNamespace().get_enkf_infile = cwrapper.prototype( "char* enkf_config_node_get_enkf_infile(enkf_config_node)")
raise NotImplementedError("Class can not be instantiated directly!") def hasWorkflow(self): """ @rtype: bool """ return PostSimulationHook.cNamespace().has_workflow(self) def getWorkflow(self): """ @rtype: Workflow """ return PostSimulationHook.cNamespace().get_workflow(self) def checkRunpathListFile(self): """ @rtype: bool """ runpath_list_file = PostSimulationHook.cNamespace().get_runpath_list_file(self) if not os.path.exists(runpath_list_file): sys.stderr.write("** Warning: the file: %s with a list of runpath directories was not found - QC workflow wil probably fail.\n" % runpath_list_file) def getRunpathList(self): """ @rtype: RunpathList """ return PostSimulationHook.cNamespace().get_runpath_list(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("qc_module", PostSimulationHook) PostSimulationHook.cNamespace().has_workflow = cwrapper.prototype("bool qc_module_has_workflow(qc_module)") PostSimulationHook.cNamespace().get_workflow = cwrapper.prototype("workflow_ref qc_module_get_workflow(qc_module)") PostSimulationHook.cNamespace().get_runpath_list_file = cwrapper.prototype("char* qc_module_get_runpath_list_file(qc_module)") PostSimulationHook.cNamespace().get_runpath_list = cwrapper.prototype("runpath_list_ref qc_module_get_runpath_list(qc_module)")
""" @rtype: Workflow """ return PostSimulationHook.cNamespace().get_workflow(self) def checkRunpathListFile(self): """ @rtype: bool """ runpath_list_file = PostSimulationHook.cNamespace( ).get_runpath_list_file(self) if not os.path.exists(runpath_list_file): sys.stderr.write( "** Warning: the file: %s with a list of runpath directories was not found - QC workflow wil probably fail.\n" % runpath_list_file) def getRunpathList(self): """ @rtype: RunpathList """ return PostSimulationHook.cNamespace().get_runpath_list(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("hook_manager", PostSimulationHook) PostSimulationHook.cNamespace().has_workflow = cwrapper.prototype( "bool hook_manager_has_workflow(hook_manager)") PostSimulationHook.cNamespace().get_workflow = cwrapper.prototype( "workflow_ref hook_manager_get_workflow(hook_manager)") PostSimulationHook.cNamespace().get_runpath_list_file = cwrapper.prototype( "char* hook_manager_get_runpath_list_file(hook_manager)") PostSimulationHook.cNamespace().get_runpath_list = cwrapper.prototype( "runpath_list_ref hook_manager_get_runpath_list(hook_manager)")
test_lib = clib.ert_load( "libert_util" ) # create a local namespace (so we don't overwrite StringList) cwrapper = CWrapper(test_lib) class StringListTest(BaseCClass): def __init__(self): c_pointer = self.cNamespace().alloc() super(StringListTest, self).__init__(c_pointer) def free(self): StringListTest.cNamespace().free(self) CWrapper.registerObjectType("stringlisttest", StringListTest) StringListTest.cNamespace().alloc = cwrapper.prototype( "c_void_p stringlist_alloc_new( )") StringListTest.cNamespace().free = cwrapper.prototype( "void stringlist_free(stringlisttest )") class CWrapTest(ExtendedTestCase): def test_return_type(self): stringlist_alloc = cwrapper.prototype( "c_void_p stringlist_alloc_new( )") string_list1 = StringListTest() stringlist_alloc = cwrapper.prototype( "stringlisttest_obj stringlist_alloc_new( )")
ct = CTime(currentTime) timeVector.append(ct) currentTime = timeVector.nextTime(num, timeUnit) return timeVector def getDataPtr(self): raise NotImplementedError( "The getDataPtr() function is not implemented for time_t vectors") ################################################################# cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("time_t_vector", TimeVector) TimeVector.cNamespace().alloc = cwrapper.prototype( "c_void_p time_t_vector_alloc(int, time_t )") TimeVector.cNamespace().alloc_copy = cwrapper.prototype( "time_t_vector_obj time_t_vector_alloc_copy(time_t_vector )") TimeVector.cNamespace().strided_copy = cwrapper.prototype( "time_t_vector_obj time_t_vector_alloc_strided_copy(time_t_vector , time_t , time_t , time_t)" ) TimeVector.cNamespace().free = cwrapper.prototype( "void time_t_vector_free( time_t_vector )") TimeVector.cNamespace().iget = cwrapper.prototype( "time_t time_t_vector_iget( time_t_vector , int )") TimeVector.cNamespace().safe_iget = cwrapper.prototype( "time_t time_t_vector_safe_iget( time_t_vector , int )") TimeVector.cNamespace().iset = cwrapper.prototype(
def scale(self, S, E=None, D=None, R=None, D_obs=None): assert isinstance(S, Matrix) assert isinstance(E, (Matrix, NoneType)) assert isinstance(D, (Matrix, NoneType)) assert isinstance(R, (Matrix, NoneType)) assert isinstance(D_obs, (Matrix, NoneType)) ObsData.cNamespace().scale(self, S, E, D, R, D_obs) def free(self): ObsData.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("obs_data", ObsData) ObsData.cNamespace().alloc = cwrapper.prototype("c_void_p obs_data_alloc(double)") ObsData.cNamespace().free = cwrapper.prototype("void obs_data_free(obs_data)") ObsData.cNamespace().total_size = cwrapper.prototype("int obs_data_get_total_size(obs_data)") ObsData.cNamespace().iget_value = cwrapper.prototype("double obs_data_iget_value(obs_data)") ObsData.cNamespace().iget_std = cwrapper.prototype("double obs_data_iget_std(obs_data)") ObsData.cNamespace().add_block = cwrapper.prototype("obs_block_ref obs_data_add_block(obs_data , char* , int , matrix , bool)") ObsData.cNamespace().allocdObs = cwrapper.prototype("matrix_obj obs_data_allocdObs(obs_data)") ObsData.cNamespace().allocR = cwrapper.prototype("matrix_obj obs_data_allocR(obs_data)") ObsData.cNamespace().allocD = cwrapper.prototype("matrix_obj obs_data_allocD(obs_data , matrix , matrix)") ObsData.cNamespace().allocE = cwrapper.prototype("matrix_obj obs_data_allocE(obs_data , rng , int)") ObsData.cNamespace().scale = cwrapper.prototype("void obs_data_scale(obs_data, matrix, matrix, matrix, matrix, matrix)") ObsData.cNamespace().scale_matrix = cwrapper.prototype("void obs_data_scale_matrix(obs_data, matrix)") ObsData.cNamespace().scale_Rmatrix = cwrapper.prototype("void obs_data_scale_Rmatrix(obs_data, matrix)")
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 HookManager.cNamespace().get_runpath_list(self) 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()) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("hook_manager", HookManager) HookManager.cNamespace().get_runpath_list_file = cwrapper.prototype( "char* hook_manager_get_runpath_list_file(hook_manager)") HookManager.cNamespace().iget_hook_workflow = cwrapper.prototype( "hook_workflow_ref hook_manager_iget_hook_workflow(hook_manager, int)") HookManager.cNamespace().size = cwrapper.prototype( "int hook_manager_get_size(hook_manager)")
def free(self): GenData.cNamespace().free(self) def export(self, file_name, file_format_type, fortio): """ @type: str @type: GenDataFileType @type: FortIO """ GenData.cNamespace().export(self, file_name, file_format_type, fortio) def getData(self): data = DoubleVector() GenData.cNamespace().export_data(self, data) return data cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("gen_data", GenData) GenData.cNamespace().alloc = cwrapper.prototype("c_void_p gen_data_alloc()") GenData.cNamespace().free = cwrapper.prototype("void gen_data_free(gen_data)") GenData.cNamespace().size = cwrapper.prototype( "int gen_data_get_size(gen_data)") GenData.cNamespace().export = cwrapper.prototype( "void gen_data_export(gen_data , char*, gen_data_file_format_type, fortio)" ) GenData.cNamespace().export_data = cwrapper.prototype( "void gen_data_export_data(gen_data , double_vector)")
def checkRunpathListFile(self): """ @rtype: bool """ runpath_list_file = HookManager.cNamespace().get_runpath_list_file(self) 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 HookManager.cNamespace().get_runpath_list(self) def hasPostHookWorkflow(self): """ @rtype: bool """ return HookManager.cNamespace().has_post_hook_workflow(self) def getPostHookWorkflow(self): """ @rtype: HookWorkflow """ return HookManager.cNamespace().get_post_hook_workflow(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("hook_manager", HookManager) HookManager.cNamespace().get_runpath_list_file = cwrapper.prototype("char* hook_manager_get_runpath_list_file(hook_manager)") HookManager.cNamespace().has_hook_workflow = cwrapper.prototype("bool hook_manager_has_hook_workflow(hook_manager)") HookManager.cNamespace().get_hook_workflow = cwrapper.prototype("hook_workflow_ref hook_manager_get_hook_workflow(hook_manager)") HookManager.cNamespace().has_post_hook_workflow = cwrapper.prototype("bool hook_manager_has_post_hook_workflow(hook_manager)") HookManager.cNamespace().get_post_hook_workflow = cwrapper.prototype("hook_workflow_ref hook_manager_get_post_hook_workflow(hook_manager)")
# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> # for more details. from ert.cwrap import CWrapper from ert.util import UTIL_LIB, VectorTemplate class DoubleVector(VectorTemplate): default_format = "%8.4f" def __init__(self, default_value=0, initial_size=0): super(DoubleVector, self).__init__(default_value, initial_size) cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("double_vector", DoubleVector) DoubleVector.cNamespace().alloc = cwrapper.prototype( "c_void_p double_vector_alloc( int , double )") DoubleVector.cNamespace().alloc_copy = cwrapper.prototype( "double_vector_obj double_vector_alloc_copy( double_vector )") DoubleVector.cNamespace().strided_copy = cwrapper.prototype( "double_vector_obj double_vector_alloc_strided_copy( double_vector , int , int , int)" ) DoubleVector.cNamespace().free = cwrapper.prototype( "void double_vector_free( double_vector )") DoubleVector.cNamespace().iget = cwrapper.prototype( "double double_vector_iget( double_vector , int )") DoubleVector.cNamespace().safe_iget = cwrapper.prototype( "double double_vector_safe_iget(double_vector , int )") DoubleVector.cNamespace().iset = cwrapper.prototype(
raise NotImplementedError("Class can not be instantiated directly!") def hasWorkflow(self): """ @rtype: bool """ return PostSimulationHook.cNamespace().has_workflow(self) def getWorkflow(self): """ @rtype: Workflow """ return PostSimulationHook.cNamespace().get_workflow(self) def checkRunpathListFile(self): """ @rtype: bool """ runpath_list_file = PostSimulationHook.cNamespace().get_runpath_list_file(self) if not os.path.exists(runpath_list_file): sys.stderr.write("** Warning: the file: %s with a list of runpath directories was not found - QC workflow wil probably fail.\n" % runpath_list_file) def getRunpathList(self): """ @rtype: RunpathList """ return PostSimulationHook.cNamespace().get_runpath_list(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("hook_manager", PostSimulationHook) PostSimulationHook.cNamespace().has_workflow = cwrapper.prototype("bool hook_manager_has_workflow(hook_manager)") PostSimulationHook.cNamespace().get_workflow = cwrapper.prototype("workflow_ref hook_manager_get_workflow(hook_manager)") PostSimulationHook.cNamespace().get_runpath_list_file = cwrapper.prototype("char* hook_manager_get_runpath_list_file(hook_manager)") PostSimulationHook.cNamespace().get_runpath_list = cwrapper.prototype("runpath_list_ref hook_manager_get_runpath_list(hook_manager)")
def attachObsset(self, obs_set): assert isinstance(obs_set, LocalObsdata) LocalMinistep.cNamespace().attach_obsset(self,obs_set) def attachDataset(self, dataset): assert isinstance(dataset, LocalDataset) LocalMinistep.cNamespace().attach_dataset(self,dataset) def getLocalObsData(self): """ @rtype: LocalObsdata """ return LocalMinistep.cNamespace().get_local_obs_data(self) def getName(self): """ @rtype: str """ return LocalMinistep.cNamespace().name(self) def free(self): LocalMinistep.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("local_ministep", LocalMinistep) LocalMinistep.cNamespace().alloc = cwrapper.prototype("c_void_p local_ministep_alloc(char*)") LocalMinistep.cNamespace().add_node = cwrapper.prototype("void local_ministep_add_obsdata_node(local_ministep,local_obsdata_node)") LocalMinistep.cNamespace().get_local_obs_data = cwrapper.prototype("local_obsdata_ref local_ministep_get_obsdata(local_ministep)") LocalMinistep.cNamespace().free = cwrapper.prototype("void local_ministep_free(local_ministep)") LocalMinistep.cNamespace().attach_obsset = cwrapper.prototype("void local_ministep_add_obsdata(local_ministep,local_obsdata)") LocalMinistep.cNamespace().attach_dataset = cwrapper.prototype("void local_ministep_add_dataset(local_ministep,local_dataset)") LocalMinistep.cNamespace().name = cwrapper.prototype("char* local_ministep_get_name(local_ministep)")
self, fs, iactive, init_mode=EnkfInitModeEnum.INIT_CONDITIONAL, iteration=0): return EnKFMain.cNamespace().alloc_run_context_ENSEMBLE_EXPERIMENT( self, fs, iactive, init_mode, iteration) def getRunpathList(self): return EnKFMain.cNamespace().get_runpath_list(self) ################################################################## cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_main", EnKFMain) EnKFMain.cNamespace().bootstrap = cwrapper.prototype( "c_void_p enkf_main_bootstrap(char*, bool, bool)") EnKFMain.cNamespace().free = cwrapper.prototype( "void enkf_main_free(enkf_main)") EnKFMain.cNamespace().get_ensemble_size = cwrapper.prototype( "int enkf_main_get_ensemble_size( enkf_main )") EnKFMain.cNamespace().get_ens_config = cwrapper.prototype( "ens_config_ref enkf_main_get_ensemble_config( enkf_main )") EnKFMain.cNamespace().get_model_config = cwrapper.prototype( "model_config_ref enkf_main_get_model_config( enkf_main )") EnKFMain.cNamespace().get_local_config = cwrapper.prototype( "local_config_ref enkf_main_get_local_config( enkf_main )") EnKFMain.cNamespace().get_analysis_config = cwrapper.prototype(
p2 = GeometryTools.nearestPointOnPolyline( end2 , target ) d1 = GeometryTools.distance( p1 , end1 ) d2 = GeometryTools.distance( p2 , end2 ) if d1 < d2: return [end1 , p1] else: return [end2 , p2] ################################################################# cwrapper = CWrapper(ERT_GEOMETRY_LIB) cwrapper.registerObjectType("geo_polygon", CPolyline) CPolyline.cNamespace().alloc_new = cwrapper.prototype("c_void_p geo_polygon_alloc( char* )") CPolyline.cNamespace().fread_alloc_irap = cwrapper.prototype("geo_polygon_obj geo_polygon_fload_alloc_irap( char* )") CPolyline.cNamespace().add_point = cwrapper.prototype("void geo_polygon_add_point( geo_polygon , double , double )") CPolyline.cNamespace().add_point_front = cwrapper.prototype("void geo_polygon_add_point_front( geo_polygon , double , double )") CPolyline.cNamespace().free = cwrapper.prototype("void geo_polygon_free( geo_polygon )") CPolyline.cNamespace().size = cwrapper.prototype("int geo_polygon_get_size( geo_polygon )") CPolyline.cNamespace().iget_xy = cwrapper.prototype("void geo_polygon_iget_xy( geo_polygon , int , double* , double* )") CPolyline.cNamespace().segment_intersects = cwrapper.prototype("bool geo_polygon_segment_intersects( geo_polygon , double , double, double , double)") CPolyline.cNamespace().get_name = cwrapper.prototype("char* geo_polygon_get_name( geo_polygon )") CPolyline.cNamespace().set_name = cwrapper.prototype("void geo_polygon_set_name( geo_polygon , char* )") CPolyline.cNamespace().segment_length = cwrapper.prototype("double geo_polygon_get_length( geo_polygon)") CPolyline.cNamespace().equal = cwrapper.prototype("bool geo_polygon_equal( geo_polygon , geo_polygon )")
# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> # for more details. from ert.cwrap import CWrapper from ert.util import UTIL_LIB, VectorTemplate class DoubleVector(VectorTemplate): default_format = "%8.4f" def __init__(self, default_value=0, initial_size=0): super(DoubleVector, self).__init__(default_value, initial_size) cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("double_vector", DoubleVector) DoubleVector.cNamespace().alloc = cwrapper.prototype("c_void_p double_vector_alloc( int , double )") DoubleVector.cNamespace().alloc_copy = cwrapper.prototype("double_vector_obj double_vector_alloc_copy( double_vector )") DoubleVector.cNamespace().strided_copy = cwrapper.prototype("double_vector_obj double_vector_alloc_strided_copy( double_vector , int , int , int)") DoubleVector.cNamespace().free = cwrapper.prototype("void double_vector_free( double_vector )") DoubleVector.cNamespace().iget = cwrapper.prototype("double double_vector_iget( double_vector , int )") DoubleVector.cNamespace().safe_iget = cwrapper.prototype("double double_vector_safe_iget(double_vector , int )") DoubleVector.cNamespace().iset = cwrapper.prototype("double double_vector_iset( double_vector , int , double)") DoubleVector.cNamespace().size = cwrapper.prototype("int double_vector_size( double_vector )") DoubleVector.cNamespace().append = cwrapper.prototype("void double_vector_append( double_vector , double )") DoubleVector.cNamespace().idel_block = cwrapper.prototype("void double_vector_idel_block( double_vector , int , int )") DoubleVector.cNamespace().pop = cwrapper.prototype("double double_vector_pop( double_vector )") DoubleVector.cNamespace().idel = cwrapper.prototype("void double_vector_idel( double_vector , int )") DoubleVector.cNamespace().lshift = cwrapper.prototype("void double_vector_lshift( double_vector , int )")
self.__test_name = test_name self.__model_config = model_config self.__site_config = site_config self.__store_area = store_area self.__test_context = ErtTest(self.__test_name, self.__model_config, site_config=self.__site_config, store_area=self.__store_area) def __enter__(self): """ @rtype: ErtTest """ return self.__test_context def __exit__(self, exc_type, exc_val, exc_tb): del self.__test_context return False def getErt(self): return self.__test_context.getErt() cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("ert_test", ErtTest) ErtTest.cNamespace().alloc = cwrapper.prototype("c_void_p ert_test_context_alloc( char* , char* , char*)") ErtTest.cNamespace().set_store = cwrapper.prototype("c_void_p ert_test_context_set_store( ert_test , bool)") ErtTest.cNamespace().free = cwrapper.prototype("void ert_test_context_free( ert_test )") ErtTest.cNamespace().get_enkf_main = cwrapper.prototype("enkf_main_ref ert_test_context_get_main( ert_test )")
def cellsEqual(self , value): """ Will return a list [(i1,j1),(i2,j2) , ...(in,jn)] of all cells with value @value. """ i_list = IntVector() j_list = IntVector() Layer.cNamespace().cells_equal( self , value , i_list , j_list) ij_list= [] for (i,j) in zip(i_list , j_list): ij_list.append( (i,j) ) return ij_list cwrapper = CWrapper(ECL_LIB) CWrapper.registerObjectType("layer", Layer) Layer.cNamespace().alloc = cwrapper.prototype("c_void_p layer_alloc(int, int)") Layer.cNamespace().copy = cwrapper.prototype("void layer_memcpy(layer , layer)") Layer.cNamespace().free = cwrapper.prototype("void layer_free(layer)") Layer.cNamespace().get_nx = cwrapper.prototype("int layer_get_nx(layer)") Layer.cNamespace().get_ny = cwrapper.prototype("int layer_get_ny(layer)") Layer.cNamespace().set_cell = cwrapper.prototype("void layer_iset_cell_value(layer , int , int , int)") Layer.cNamespace().get_cell = cwrapper.prototype("int layer_iget_cell_value(layer , int , int )") Layer.cNamespace().get_bottom_barrier = cwrapper.prototype("bool layer_iget_bottom_barrier(layer , int , int )") Layer.cNamespace().get_left_barrier = cwrapper.prototype("bool layer_iget_left_barrier(layer , int , int )") Layer.cNamespace().cell_contact = cwrapper.prototype("bool layer_cell_contact(layer , int , int , int , int)") Layer.cNamespace().add_barrier = cwrapper.prototype("void layer_add_barrier(layer , int , int)") Layer.cNamespace().add_ijbarrier = cwrapper.prototype("void layer_add_ijbarrier(layer , int , int, int , int)") Layer.cNamespace().add_interp_barrier = cwrapper.prototype("void layer_add_interp_barrier(layer , int , int)") Layer.cNamespace().clear_cells = cwrapper.prototype("void layer_clear_cells(layer)") Layer.cNamespace().assign = cwrapper.prototype("void layer_assign(layer , int)")
def cellsEqual(self, value): """ Will return a list [(i1,j1),(i2,j2) , ...(in,jn)] of all cells with value @value. """ i_list = IntVector() j_list = IntVector() Layer.cNamespace().cells_equal(self, value, i_list, j_list) ij_list = [] for (i, j) in zip(i_list, j_list): ij_list.append((i, j)) return ij_list cwrapper = CWrapper(ECL_LIB) CWrapper.registerObjectType("layer", Layer) Layer.cNamespace().alloc = cwrapper.prototype( "c_void_p layer_alloc(int, int)") Layer.cNamespace().copy = cwrapper.prototype( "void layer_memcpy(layer , layer)") Layer.cNamespace().free = cwrapper.prototype("void layer_free(layer)") Layer.cNamespace().get_nx = cwrapper.prototype("int layer_get_nx(layer)") Layer.cNamespace().get_ny = cwrapper.prototype("int layer_get_ny(layer)") Layer.cNamespace().set_cell = cwrapper.prototype( "void layer_iset_cell_value(layer , int , int , int)") Layer.cNamespace().get_cell = cwrapper.prototype( "int layer_iget_cell_value(layer , int , int )") Layer.cNamespace().get_bottom_barrier = cwrapper.prototype( "bool layer_iget_bottom_barrier(layer , int , int )") Layer.cNamespace().get_left_barrier = cwrapper.prototype( "bool layer_iget_left_barrier(layer , int , int )")
def getJobnameFormat(self): """ @rtype: str """ return ModelConfig.cNamespace().get_jobname_fmt(self) def getEnspath(self): """ @rtype: str """ return ModelConfig.cNamespace().get_enspath(self) def getRunpathFormat(self): """ @rtype: PathFormat """ return ModelConfig.cNamespace().get_runpath_fmt(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("model_config", ModelConfig) ModelConfig.cNamespace().free = cwrapper.prototype( "void model_config_free( model_config )") ModelConfig.cNamespace().get_enkf_sched_file = cwrapper.prototype( "char* model_config_get_enkf_sched_file( model_config )") ModelConfig.cNamespace().set_enkf_sched_file = cwrapper.prototype( "void model_config_set_enkf_sched_file( model_config, char*)") ModelConfig.cNamespace().get_forward_model = cwrapper.prototype( "forward_model_ref model_config_get_forward_model(model_config)") ModelConfig.cNamespace().get_max_internal_submit = cwrapper.prototype( "int model_config_get_max_internal_submit(model_config)") ModelConfig.cNamespace().set_max_internal_submit = cwrapper.prototype( "void model_config_set_max_internal_submit(model_config, int)") ModelConfig.cNamespace().get_case_table_file = cwrapper.prototype( "char* model_config_get_case_table_file(model_config)")
if os.path.exists(config_file): config_content = ConfigParser.cNamespace().parse(self, config_file, comment_string, include_kw, define_kw, unrecognized, validate) if config_content.isValid(): return config_content else: raise Exception("Parsing:%s failed" % config_file) else: raise IOError("File: %s does not exists" % config_file) def free(self): ConfigParser.cNamespace().free(self) cwrapper = CWrapper(CONFIG_LIB) cwrapper.registerObjectType("config_parser", ConfigParser) cwrapper.registerObjectType("schema_item", SchemaItem) ConfigParser.cNamespace().alloc = cwrapper.prototype("c_void_p config_alloc( )") ConfigParser.cNamespace().add = cwrapper.prototype("schema_item_ref config_add_schema_item( config_parser , char* , bool)") ConfigParser.cNamespace().free = cwrapper.prototype("void config_free( config_parser )") ConfigParser.cNamespace().parse = cwrapper.prototype("config_content_obj config_parse( config_parser , char* , char* , char* , char* , config_unrecognized_enum , bool )") ConfigParser.cNamespace().get_schema_item = cwrapper.prototype("schema_item_ref config_get_schema_item( config_parser , char*)") ConfigParser.cNamespace().has_schema_item = cwrapper.prototype("bool config_has_schema_item( config_parser , char*)") SchemaItem.cNamespace().alloc = cwrapper.prototype("c_void_p config_schema_item_alloc( char* , bool )") SchemaItem.cNamespace().free = cwrapper.prototype("void config_schema_item_free( schema_item )") SchemaItem.cNamespace().iget_type = cwrapper.prototype("config_content_type_enum config_schema_item_iget_type( schema_item, int)") SchemaItem.cNamespace().iset_type = cwrapper.prototype("void config_schema_item_iset_type( schema_item , int , config_content_type_enum)") SchemaItem.cNamespace().set_argc_minmax = cwrapper.prototype("void config_schema_item_set_argc_minmax( schema_item , int , int)")
ArgPack.cNamespace().append_int( self , data ) elif isinstance(data , float): ArgPack.cNamespace().append_double( self , data ) elif isinstance(data , BaseCClass): ArgPack.cNamespace().append_ptr( self , BaseCClass.from_param( data ) ) self.child_list.append( data ) else: raise TypeError("Can only add int/double/basecclass") def __len__(self): return ArgPack.cNamespace().size(self) def free(self): ArgPack.cNamespace().free(self) CWrapper.registerObjectType("arg_pack", ArgPack) cwrapper = CWrapper(UTIL_LIB) ArgPack.cNamespace().alloc = cwrapper.prototype("c_void_p arg_pack_alloc( )") ArgPack.cNamespace().free = cwrapper.prototype("void arg_pack_free(arg_pack )") ArgPack.cNamespace().size = cwrapper.prototype("int arg_pack_size(arg_pack )") ArgPack.cNamespace().append_int = cwrapper.prototype("void arg_pack_append_int(arg_pack , int)") ArgPack.cNamespace().append_double = cwrapper.prototype("void arg_pack_append_double(arg_pack ,double)") ArgPack.cNamespace().append_ptr = cwrapper.prototype("void arg_pack_append_ptr(arg_pack , c_void_p)")
LocalMinistep.cNamespace().attach_dataset(self, dataset) def getLocalObsData(self): """ @rtype: LocalObsdata """ return LocalMinistep.cNamespace().get_local_obs_data(self) def getName(self): """ @rtype: str """ return LocalMinistep.cNamespace().name(self) def free(self): LocalMinistep.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("local_ministep", LocalMinistep) LocalMinistep.cNamespace().alloc = cwrapper.prototype( "c_void_p local_ministep_alloc(char*)") LocalMinistep.cNamespace().add_node = cwrapper.prototype( "void local_ministep_add_obsdata_node(local_ministep,local_obsdata_node)") LocalMinistep.cNamespace().get_local_obs_data = cwrapper.prototype( "local_obsdata_ref local_ministep_get_obsdata(local_ministep)") LocalMinistep.cNamespace().get_local_data = cwrapper.prototype( "local_dataset_ref local_ministep_get_dataset(local_ministep , char*)") LocalMinistep.cNamespace().has_local_data = cwrapper.prototype( "bool local_ministep_has_dataset(local_ministep , char*)") LocalMinistep.cNamespace().free = cwrapper.prototype( "void local_ministep_free(local_ministep)") LocalMinistep.cNamespace().attach_obsdata = cwrapper.prototype( "void local_ministep_add_obsdata(local_ministep,local_obsdata)")
LocalDataset.cNamespace().add_node(self, key) active_list = self.getActiveList(key) active_region = ecl_region.getActiveList() for i in active_region: active_list.addActiveIndex(i) def free(self): LocalDataset.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("local_dataset", LocalDataset) LocalDataset.cNamespace().alloc = cwrapper.prototype("c_void_p local_dataset_alloc(char*)") LocalDataset.cNamespace().size = cwrapper.prototype("c_void_p local_dataset_get_size(char*)") LocalDataset.cNamespace().has_key = cwrapper.prototype("bool local_dataset_has_key(local_dataset, char*)") LocalDataset.cNamespace().free = cwrapper.prototype("void local_dataset_free(local_dataset)") LocalDataset.cNamespace().name = cwrapper.prototype("char* local_dataset_get_name(local_dataset)") LocalDataset.cNamespace().active_list = cwrapper.prototype("active_list_ref local_dataset_get_node_active_list(local_dataset, char*)") LocalDataset.cNamespace().add_node = cwrapper.prototype("void local_dataset_add_node(local_dataset, char*)") LocalDataset.cNamespace().del_node = cwrapper.prototype("void local_dataset_del_node(local_dataset, char*)")
@type realization_number: int @type iteration_number: int @type runpath: int @type basename: int """ RunpathList.cNamespace().add(self, realization_number, iteration_number, runpath, basename) def clear(self): RunpathList.cNamespace().clear(self) def free(self): RunpathList.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("runpath_list", RunpathList) RunpathList.cNamespace().free = cwrapper.prototype("void runpath_list_free(runpath_list)") RunpathList.cNamespace().add = cwrapper.prototype("void runpath_list_add(runpath_list, int, int, char*, char*)") RunpathList.cNamespace().clear = cwrapper.prototype("void runpath_list_clear(runpath_list)") RunpathList.cNamespace().size = cwrapper.prototype("int runpath_list_size(runpath_list)") RunpathList.cNamespace().iens = cwrapper.prototype("int runpath_list_iget_iens(runpath_list, int)") RunpathList.cNamespace().iteration = cwrapper.prototype("int runpath_list_iget_iter(runpath_list, int)") RunpathList.cNamespace().runpath = cwrapper.prototype("char* runpath_list_iget_runpath(runpath_list, int)") RunpathList.cNamespace().basename = cwrapper.prototype("char* runpath_list_iget_basename(runpath_list, int)")
def insertBlockContent(self , block): self.cNamespace().insert_block_content(self , block) def exportKeyword(self , kw): if len(kw) != self.grid_ref.getGlobalSize(): raise ValueError("The size of the target keyword must be equal to the size of the grid. Got:%d Expected:%d" % (len(kw) , self.grid_ref.getGlobalSize())) if kw.getEclType() != EclTypeEnum.ECL_INT_TYPE: raise TypeError("The target kewyord must be of integer type") self.cNamespace().export_kw( self , kw ) cwrapper = CWrapper(ECL_LIB) CWrapper.registerObjectType("fault_block_layer", FaultBlockLayer) FaultBlockLayer.cNamespace().alloc = cwrapper.prototype("c_void_p fault_block_layer_alloc(ecl_grid , int)") FaultBlockLayer.cNamespace().free = cwrapper.prototype("void fault_block_layer_free(fault_block_layer)") FaultBlockLayer.cNamespace().size = cwrapper.prototype("int fault_block_layer_get_size(fault_block_layer)") FaultBlockLayer.cNamespace().iget_block = cwrapper.prototype("fault_block_ref fault_block_layer_iget_block(fault_block_layer, int)") FaultBlockLayer.cNamespace().add_block = cwrapper.prototype("fault_block_ref fault_block_layer_add_block(fault_block_layer, int)") FaultBlockLayer.cNamespace().get_block = cwrapper.prototype("fault_block_ref fault_block_layer_get_block(fault_block_layer, int)") FaultBlockLayer.cNamespace().del_block = cwrapper.prototype("void fault_block_layer_del_block(fault_block_layer, int)") FaultBlockLayer.cNamespace().has_block = cwrapper.prototype("bool fault_block_layer_has_block(fault_block_layer, int)") FaultBlockLayer.cNamespace().scan_keyword = cwrapper.prototype("bool fault_block_layer_scan_kw(fault_block_layer, ecl_kw)") FaultBlockLayer.cNamespace().load_keyword = cwrapper.prototype("bool fault_block_layer_load_kw(fault_block_layer, ecl_kw)") FaultBlockLayer.cNamespace().getK = cwrapper.prototype("int fault_block_layer_get_k(fault_block_layer)") FaultBlockLayer.cNamespace().get_next_id = cwrapper.prototype("int fault_block_layer_get_next_id(fault_block_layer)") FaultBlockLayer.cNamespace().scan_layer = cwrapper.prototype("void fault_block_layer_scan_layer( fault_block_layer , layer)")
def hasKey(self, key): return key in self def getValue(self, key, item_index=-1, node_index=0): item = self[key] return item.getValue(item_index, node_index) def isValid(self): return ConfigContent.cNamespace().is_valid(self) def free(self): ConfigContent.cNamespace().free(self) cwrapper = CWrapper(CONFIG_LIB) cwrapper.registerObjectType("config_content", ConfigContent) cwrapper.registerObjectType("content_item", ContentItem) cwrapper.registerObjectType("content_node", ContentNode) ConfigContent.cNamespace().free = cwrapper.prototype( "void config_content_free( config_content )") ConfigContent.cNamespace().is_valid = cwrapper.prototype( "bool config_content_is_valid( config_content )") ConfigContent.cNamespace().has_key = cwrapper.prototype( "bool config_content_has_item( config_content , char*)") ConfigContent.cNamespace().get_item = cwrapper.prototype( "content_item_ref config_content_get_item( config_content , char*)") ContentItem.cNamespace().size = cwrapper.prototype( "int config_content_item_get_size( content_item )") ContentItem.cNamespace().iget_content_node = cwrapper.prototype(
def load(self , config_file): if not os.path.isfile( config_file ): raise IOError("The observation config file:%s does not exist" % config_file) return EnkfObs.cNamespace().load( self , config_file ) def clear(self): EnkfObs.cNamespace().clear( self ) def free(self): EnkfObs.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_obs", EnkfObs) EnkfObs.cNamespace().alloc = cwrapper.prototype("c_void_p enkf_obs_alloc( history , time_map , ecl_grid , ecl_sum , ens_config )") EnkfObs.cNamespace().free = cwrapper.prototype("void enkf_obs_free( enkf_obs )") EnkfObs.cNamespace().get_size = cwrapper.prototype("int enkf_obs_get_size( enkf_obs )") EnkfObs.cNamespace().load = cwrapper.prototype("bool enkf_obs_load( enkf_obs , char*)") EnkfObs.cNamespace().clear = cwrapper.prototype("void enkf_obs_clear( enkf_obs )") EnkfObs.cNamespace().alloc_typed_keylist = cwrapper.prototype("stringlist_obj enkf_obs_alloc_typed_keylist(enkf_obs, enkf_obs_impl_type)") EnkfObs.cNamespace().alloc_matching_keylist = cwrapper.prototype("stringlist_obj enkf_obs_alloc_matching_keylist(enkf_obs, char*)") EnkfObs.cNamespace().has_key = cwrapper.prototype("bool enkf_obs_has_key(enkf_obs, char*)") EnkfObs.cNamespace().obs_type = cwrapper.prototype("enkf_obs_impl_type enkf_obs_get_type(enkf_obs, char*)") EnkfObs.cNamespace().get_vector = cwrapper.prototype("obs_vector_ref enkf_obs_get_vector(enkf_obs, char*)") EnkfObs.cNamespace().iget_vector = cwrapper.prototype("obs_vector_ref enkf_obs_iget_vector(enkf_obs, int)") EnkfObs.cNamespace().iget_obs_time = cwrapper.prototype("time_t enkf_obs_iget_obs_time(enkf_obs, int)") EnkfObs.cNamespace().add_obs_vector = cwrapper.prototype("void enkf_obs_add_obs_vector(enkf_obs, obs_vector)")
from ert.cwrap import BaseCClass, CWrapper from ert.enkf import ENKF_LIB class ActiveList(BaseCClass): def __init__(self): c_ptr = ActiveList.cNamespace().alloc() super(ActiveList, self).__init__(c_ptr) def getMode(self): return ActiveList.cNamespace().get_mode(self) def addActiveIndex(self, index): ActiveList.cNamespace().add_index(self, index) def free(self): ActiveList.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("active_list", ActiveList) ActiveList.cNamespace().alloc = cwrapper.prototype( "c_void_p active_list_alloc()") ActiveList.cNamespace().free = cwrapper.prototype( "void active_list_free(active_list)") ActiveList.cNamespace().get_mode = cwrapper.prototype( "active_mode_enum active_list_get_mode(active_list)") ActiveList.cNamespace().add_index = cwrapper.prototype( "void active_list_add_index(active_list , int)")
def hasWorkflow(self): """ @rtype: bool """ return PostSimulationHook.cNamespace().has_workflow(self) def getWorkflow(self): """ @rtype: Workflow """ return PostSimulationHook.cNamespace().get_workflow(self) def checkRunpathListFile(self): """ @rtype: bool """ runpath_list_file = PostSimulationHook.cNamespace( ).get_runpath_list_file(self) if not os.path.exists(runpath_list_file): sys.stderr.write( "** Warning: the file: %s with a list of runpath directories was not found - QC workflow wil probably fail.\n" % runpath_list_file) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("qc_module", PostSimulationHook) PostSimulationHook.cNamespace().has_workflow = cwrapper.prototype( "bool qc_module_has_workflow(qc_module)") PostSimulationHook.cNamespace().get_workflow = cwrapper.prototype( "workflow_ref qc_module_get_workflow(qc_module)") PostSimulationHook.cNamespace().get_runpath_list_file = cwrapper.prototype( "char* qc_module_get_runpath_list_file(qc_module)")
def __eq__(self, other): return WellConnection.cNamespace().equal(self, other) def __ne__(self, other): return not self == other def free(self): pass def isMultiSegmentWell(self): """ @rtype: bool """ return WellConnection.cNamespace().is_msw(self) CWrapper.registerObjectType("well_connection", WellConnection) cwrapper = CWrapper(ECL_WELL_LIB) WellConnection.cNamespace().i = cwrapper.prototype( "int well_conn_get_i(well_connection)") WellConnection.cNamespace().j = cwrapper.prototype( "int well_conn_get_j(well_connection)") WellConnection.cNamespace().k = cwrapper.prototype( "int well_conn_get_k(well_connection)") WellConnection.cNamespace().get_dir = cwrapper.prototype( "well_connection_dir_enum well_conn_get_dir(well_connection)") WellConnection.cNamespace().segment_id = cwrapper.prototype( "int well_conn_get_segment_id(well_connection)") WellConnection.cNamespace().is_open = cwrapper.prototype( "bool well_conn_open(well_connection)")
def free(self): EnsembleConfig.cNamespace().free(self) def addDefinedCustomKW(self, group_name, definition): """ @rtype: EnkfConfigNode """ if not group_name in self: type_hash = CustomKWConfig.convertDefinition(definition) EnsembleConfig.cNamespace().add_defined_custom_kw(self, group_name, type_hash) return self[group_name] cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("ens_config", EnsembleConfig) EnsembleConfig.cNamespace().alloc = cwrapper.prototype("c_void_p ensemble_config_alloc( )") EnsembleConfig.cNamespace().free = cwrapper.prototype("void ensemble_config_free( ens_config )") EnsembleConfig.cNamespace().has_key = cwrapper.prototype("bool ensemble_config_has_key( ens_config , char* )") EnsembleConfig.cNamespace().size = cwrapper.prototype("int ensemble_config_get_size( ens_config)") EnsembleConfig.cNamespace().get_node = cwrapper.prototype("enkf_config_node_ref ensemble_config_get_node( ens_config , char*)") EnsembleConfig.cNamespace().alloc_keylist = cwrapper.prototype("stringlist_obj ensemble_config_alloc_keylist( ens_config )") EnsembleConfig.cNamespace().add_summary = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_summary( ens_config, char*, int)") EnsembleConfig.cNamespace().add_gen_kw = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_gen_kw( ens_config, char*)") EnsembleConfig.cNamespace().add_field = cwrapper.prototype("enkf_config_node_ref ensemble_config_add_field( ens_config, char*, ecl_grid)") EnsembleConfig.cNamespace().alloc_keylist_from_var_type = cwrapper.prototype("stringlist_obj ensemble_config_alloc_keylist_from_var_type(ens_config, enkf_var_type_enum)") EnsembleConfig.cNamespace().alloc_keylist_from_impl_type = cwrapper.prototype("stringlist_obj ensemble_config_alloc_keylist_from_impl_type(ens_config, ert_impl_type_enum)") EnsembleConfig.cNamespace().add_node = cwrapper.prototype("void ensemble_config_add_node( ens_config , enkf_config_node )") EnsembleConfig.cNamespace().summary_key_matcher = cwrapper.prototype("summary_key_matcher_ref ensemble_config_get_summary_key_matcher(ens_config)")
def getGenKWExportFile(self): """ @rtype: str """ return ModelConfig.cNamespace().gen_kw_export_file(self) def runpathRequiresIterations(self): """ @rtype: bool """ return ModelConfig.cNamespace().runpath_requires_iterations(self) def getJobnameFormat(self): """ @rtype: str """ return ModelConfig.cNamespace().get_jobname_fmt(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("model_config", ModelConfig) ModelConfig.cNamespace().free = cwrapper.prototype("void model_config_free( model_config )") ModelConfig.cNamespace().get_enkf_sched_file = cwrapper.prototype("char* model_config_get_enkf_sched_file( model_config )") ModelConfig.cNamespace().set_enkf_sched_file = cwrapper.prototype("void model_config_set_enkf_sched_file( model_config, char*)") ModelConfig.cNamespace().get_forward_model = cwrapper.prototype("forward_model_ref model_config_get_forward_model(model_config)") ModelConfig.cNamespace().get_max_internal_submit = cwrapper.prototype("int model_config_get_max_internal_submit(model_config)") ModelConfig.cNamespace().set_max_internal_submit = cwrapper.prototype("void model_config_set_max_internal_submit(model_config, int)") ModelConfig.cNamespace().get_case_table_file = cwrapper.prototype("char* model_config_get_case_table_file(model_config)") ModelConfig.cNamespace().get_runpath_as_char = cwrapper.prototype("char* model_config_get_runpath_as_char(model_config)") ModelConfig.cNamespace().select_runpath = cwrapper.prototype("bool model_config_select_runpath(model_config, char*)") ModelConfig.cNamespace().set_runpath = cwrapper.prototype("void model_config_set_runpath(model_config, char*)") ModelConfig.cNamespace().get_fs_type = cwrapper.prototype("enkf_fs_type_enum model_config_get_dbase_type(model_config)") ModelConfig.cNamespace().get_history = cwrapper.prototype("history_ref model_config_get_history(model_config)") ModelConfig.cNamespace().get_history_source = cwrapper.prototype("history_source_enum model_config_get_history_source(model_config)")
if not self.tryLoad(fs, node_id): raise Exception("Could not load node: %s iens: %d report: %d" % (self.name(), node_id.iens, node_id.report_step)) def save(self, fs, node_id): assert isinstance(fs, EnkfFs) assert isinstance(node_id, NodeId) return EnkfNode.cNamespace().store(self, fs, False, node_id) def free(self): EnkfNode.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_node", EnkfNode) EnkfNode.cNamespace().free = cwrapper.prototype( "void enkf_node_free(enkf_node)") EnkfNode.cNamespace().alloc = cwrapper.prototype( "void* enkf_node_alloc(enkf_config_node)") EnkfNode.cNamespace().alloc_private = cwrapper.prototype( "void* enkf_node_alloc_private_container(enkf_config_node)") EnkfNode.cNamespace().get_name = cwrapper.prototype( "char* enkf_node_get_key(enkf_node)") EnkfNode.cNamespace().value_ptr = cwrapper.prototype( "void* enkf_node_value_ptr(enkf_node)") EnkfNode.cNamespace().try_load = cwrapper.prototype( "bool enkf_node_try_load(enkf_node, enkf_fs, node_id)")
def getNumRetries(self): """ @rtype: int """ return AnalysisIterConfig.cNamespace().get_num_retries(self) def getCaseFormat(self): """ @rtype: str """ return AnalysisIterConfig.cNamespace().get_case_fmt(self) def setCaseFormat(self, case_fmt): AnalysisIterConfig.cNamespace().set_case_fmt(self, case_fmt) def caseFormatSet(self): return AnalysisIterConfig.cNamespace().case_fmt_set(self) def free(self): AnalysisIterConfig.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("analysis_iter_config", AnalysisIterConfig) AnalysisIterConfig.cNamespace().alloc = cwrapper.prototype("c_void_p analysis_iter_config_alloc( )") AnalysisIterConfig.cNamespace().free = cwrapper.prototype("void analysis_iter_config_free( analysis_iter_config )") AnalysisIterConfig.cNamespace().set_num_iterations = cwrapper.prototype("void analysis_iter_config_set_num_iterations(analysis_iter_config, int)") AnalysisIterConfig.cNamespace().get_num_iterations = cwrapper.prototype("int analysis_iter_config_get_num_iterations(analysis_iter_config)") AnalysisIterConfig.cNamespace().get_num_retries = cwrapper.prototype("int analysis_iter_config_get_num_retries_per_iteration(analysis_iter_config)") AnalysisIterConfig.cNamespace().num_iterations_set = cwrapper.prototype("bool analysis_iter_config_num_iterations_set(analysis_iter_config)") AnalysisIterConfig.cNamespace().set_case_fmt = cwrapper.prototype("void analysis_iter_config_set_case_fmt( analysis_iter_config , char* )") AnalysisIterConfig.cNamespace().get_case_fmt = cwrapper.prototype("char* analysis_iter_config_get_case_fmt( analysis_iter_config)") AnalysisIterConfig.cNamespace().case_fmt_set = cwrapper.prototype("bool analysis_iter_config_case_fmt_set(analysis_iter_config)")
import sys from types import IntType, SliceType from ert.cwrap import CWrapper, CFILE, BaseCClass from ert.util import UTIL_LIB class PermutationVector(BaseCClass): def __init__(self): raise NotImplementedError("Class can not be instantiated directly!") def free(self): PermutationVector.cNamespace().free(self) CWrapper.registerObjectType("permutation_vector", PermutationVector) cwrapper = CWrapper(UTIL_LIB) PermutationVector.cNamespace().free = cwrapper.prototype("void util_safe_free(permutation_vector)") # TVector takes advantage of the fact that self.cNamespace belongs to the inheriting class class VectorTemplate(BaseCClass): @classmethod def strided_copy(cls, obj, slice_range): """ Will create a new copy according to @slice. Mainly a support function to support slice based lookup like v = IntVector()
def submitSimulation(self , run_arg): EnKFMain.cNamespace().submit_simulation( self , run_arg) def getRunContextENSEMPLE_EXPERIMENT(self , fs , iactive , init_mode = EnkfInitModeEnum.INIT_CONDITIONAL , iteration = 0): return EnKFMain.cNamespace().alloc_run_context_ENSEMBLE_EXPERIMENT( self , fs , iactive , init_mode , iteration ) def getRunpathList(self): return EnKFMain.cNamespace().get_runpath_list( self ) ################################################################## cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_main", EnKFMain) EnKFMain.cNamespace().bootstrap = cwrapper.prototype("c_void_p enkf_main_bootstrap(char*, bool, bool)") EnKFMain.cNamespace().free = cwrapper.prototype("void enkf_main_free(enkf_main)") EnKFMain.cNamespace().get_ensemble_size = cwrapper.prototype("int enkf_main_get_ensemble_size( enkf_main )") EnKFMain.cNamespace().get_ens_config = cwrapper.prototype("ens_config_ref enkf_main_get_ensemble_config( enkf_main )") EnKFMain.cNamespace().get_model_config = cwrapper.prototype("model_config_ref enkf_main_get_model_config( enkf_main )") EnKFMain.cNamespace().get_local_config = cwrapper.prototype("local_config_ref enkf_main_get_local_config( enkf_main )") EnKFMain.cNamespace().get_analysis_config = cwrapper.prototype("analysis_config_ref enkf_main_get_analysis_config( enkf_main)") EnKFMain.cNamespace().get_site_config = cwrapper.prototype("site_config_ref enkf_main_get_site_config( enkf_main)") EnKFMain.cNamespace().get_ecl_config = cwrapper.prototype("ecl_config_ref enkf_main_get_ecl_config( enkf_main)") EnKFMain.cNamespace().get_plot_config = cwrapper.prototype("plot_config_ref enkf_main_get_plot_config( enkf_main)") EnKFMain.cNamespace().set_eclbase = cwrapper.prototype("ui_return_obj enkf_main_set_eclbase( enkf_main, char*)") EnKFMain.cNamespace().set_datafile = cwrapper.prototype("void enkf_main_set_data_file( enkf_main, char*)") EnKFMain.cNamespace().get_schedule_prediction_file = cwrapper.prototype("char* enkf_main_get_schedule_prediction_file( enkf_main )")
ct = CTime( currentTime ) timeVector.append( ct ) currentTime = timeVector.nextTime( num , timeUnit ) return timeVector def getDataPtr(self): raise NotImplementedError("The getDataPtr() function is not implemented for time_t vectors") ################################################################# cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("time_t_vector", TimeVector) TimeVector.cNamespace().alloc = cwrapper.prototype("c_void_p time_t_vector_alloc(int, time_t )") TimeVector.cNamespace().alloc_copy = cwrapper.prototype("time_t_vector_obj time_t_vector_alloc_copy(time_t_vector )") TimeVector.cNamespace().strided_copy = cwrapper.prototype("time_t_vector_obj time_t_vector_alloc_strided_copy(time_t_vector , time_t , time_t , time_t)") TimeVector.cNamespace().free = cwrapper.prototype("void time_t_vector_free( time_t_vector )") TimeVector.cNamespace().iget = cwrapper.prototype("time_t time_t_vector_iget( time_t_vector , int )") TimeVector.cNamespace().safe_iget = cwrapper.prototype("time_t time_t_vector_safe_iget( time_t_vector , int )") TimeVector.cNamespace().iset = cwrapper.prototype("time_t time_t_vector_iset( time_t_vector , int , time_t)") TimeVector.cNamespace().size = cwrapper.prototype("int time_t_vector_size( time_t_vector )") TimeVector.cNamespace().append = cwrapper.prototype("void time_t_vector_append( time_t_vector , time_t )") TimeVector.cNamespace().idel_block = cwrapper.prototype("void time_t_vector_idel_block( time_t_vector , int , int )") TimeVector.cNamespace().idel = cwrapper.prototype("void time_t_vector_idel( time_t_vector , int )") TimeVector.cNamespace().pop = cwrapper.prototype("time_t time_t_vector_pop( time_t_vector )") TimeVector.cNamespace().lshift = cwrapper.prototype("void time_t_vector_lshift( time_t_vector , int )")
def __len__(self): """ @rtype: int """ return WellTimeLine.cNamespace().size(self) def __getitem__(self, index): """ @type index: int @rtype: WellState """ if index < 0: index += len(self) if not 0 <= index < len(self): raise IndexError("Index must be in range 0 <= %d < %d" % (index, len(self))) return WellTimeLine.cNamespace().iget(self, index).setParent(self) def free(self): pass CWrapper.registerObjectType("well_time_line", WellTimeLine) cwrapper = CWrapper(ECL_WELL_LIB) WellTimeLine.cNamespace().size = cwrapper.prototype( "int well_ts_get_size(well_time_line)") WellTimeLine.cNamespace().iget = cwrapper.prototype( "well_state_ref well_ts_iget_state(well_time_line, int)")
def ijk_get_double(self, i, j, k): return Field.cNamespace().ijk_get_double(self, 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 Field.cNamespace().export(self , filename , None , file_type , output_transform , init_file ) return True def free(self): Field.cNamespace().free(self) ################################################################## cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("field", Field) Field.cNamespace().free = cwrapper.prototype("void field_free( field )") Field.cNamespace().ijk_get_double = cwrapper.prototype("double field_ijk_get_double(field, int, int, int)") Field.cNamespace().export = cwrapper.prototype("void field_export(field, char* , fortio , enkf_field_file_format_enum , bool , char*)")
def __len__(self): return GenKwConfig.cNamespace().size(self) def __getitem__(self, index): """ @rtype: str """ return GenKwConfig.cNamespace().iget_name(self, index) def __iter__(self): index = 0 while index < len(self): yield self[index] index += 1 cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("gen_kw_config", GenKwConfig) GenKwConfig.cNamespace().free = cwrapper.prototype("void gen_kw_config_free( gen_kw_config )") GenKwConfig.cNamespace().alloc_empty = cwrapper.prototype("c_void_p gen_kw_config_alloc_empty( char*, char* )") GenKwConfig.cNamespace().get_template_file = cwrapper.prototype("char* gen_kw_config_get_template_file(gen_kw_config)") GenKwConfig.cNamespace().set_template_file = cwrapper.prototype("void gen_kw_config_set_template_file(gen_kw_config , char*)") GenKwConfig.cNamespace().get_parameter_file = cwrapper.prototype("char* gen_kw_config_get_parameter_file(gen_kw_config)") GenKwConfig.cNamespace().set_parameter_file = cwrapper.prototype("void gen_kw_config_set_parameter_file( gen_kw_config, char* )") GenKwConfig.cNamespace().alloc_name_list = cwrapper.prototype("stringlist_obj gen_kw_config_alloc_name_list(gen_kw_config)") GenKwConfig.cNamespace().should_use_log_scale = cwrapper.prototype("bool gen_kw_config_should_use_log_scale(gen_kw_config, int)") GenKwConfig.cNamespace().get_key = cwrapper.prototype("char* gen_kw_config_get_key(gen_kw_config)") GenKwConfig.cNamespace().size = cwrapper.prototype("int gen_kw_config_get_data_size(gen_kw_config)") GenKwConfig.cNamespace().iget_name = cwrapper.prototype("char* gen_kw_config_iget_name(gen_kw_config, int)")
@type fs: EnkfFS @type node_id: NodeId @rtype: bool """ assert isinstance(fs, EnkfFs) assert isinstance(node_id, NodeId) return EnkfNode.cNamespace().try_load(self, fs, node_id) def free(self): EnkfNode.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("enkf_node", EnkfNode) EnkfNode.cNamespace().free = cwrapper.prototype("void enkf_node_free( enkf_node )") EnkfNode.cNamespace().alloc = cwrapper.prototype("c_void_p enkf_node_alloc(enkf_node)") EnkfNode.cNamespace().alloc_private = cwrapper.prototype("c_void_p enkf_node_alloc_private_container(enkf_node)") # EnkfNode.cNamespace().user_get = cwrapper.prototype("bool enkf_node_user_get_no_id(enkf_node , enkf_fs , char* , int, int , c_uint, double*)") # EnkfNode.cNamespace().user_get_vector = cwrapper.prototype("bool enkf_node_user_get_vector( enkf_node , enkf_fs , char*, int, c_uint, double_vector)") EnkfNode.cNamespace().value_ptr = cwrapper.prototype("c_void_p enkf_node_value_ptr(enkf_node)") # EnkfNode.cNamespace().vector_storage = cwrapper.prototype("bool enkf_node_vector_storage(enkf_node)") EnkfNode.cNamespace().try_load = cwrapper.prototype("bool enkf_node_try_load(enkf_node, enkf_fs, node_id)") #todo fix this # EnkfNode.cNamespace().get_config = cwrapper.prototype("c_void_p enkf_node_get_config(enkf_node)")
for index in source_list: index = int(index) bool_vector[index] = True return bool_vector @classmethod def createActiveList(cls, mask): """ @rtype: IntVectorTemplate """ assert isinstance(mask, BoolVector) return cls.cNamespace().active_list(mask) cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("bool_vector", BoolVector) BoolVector.cNamespace().alloc = cwrapper.prototype("c_void_p bool_vector_alloc( int , bool )") BoolVector.cNamespace().alloc_copy = cwrapper.prototype("bool_vector_obj bool_vector_alloc_copy( bool_vector )") BoolVector.cNamespace().strided_copy = cwrapper.prototype("bool_vector_obj bool_vector_alloc_strided_copy( bool_vector , int , int , int)") BoolVector.cNamespace().free = cwrapper.prototype("void bool_vector_free( bool_vector )") BoolVector.cNamespace().iget = cwrapper.prototype("bool bool_vector_iget( bool_vector , int )") BoolVector.cNamespace().safe_iget = cwrapper.prototype("bool bool_vector_safe_iget( bool_vector , int )") BoolVector.cNamespace().iset = cwrapper.prototype("void bool_vector_iset( bool_vector , int , bool)") BoolVector.cNamespace().size = cwrapper.prototype("int bool_vector_size( bool_vector )") BoolVector.cNamespace().append = cwrapper.prototype("void bool_vector_append( bool_vector , bool )") BoolVector.cNamespace().idel_block = cwrapper.prototype("void bool_vector_idel_block( bool_vector , bool , bool )") BoolVector.cNamespace().idel = cwrapper.prototype("void bool_vector_idel( bool_vector , int )") BoolVector.cNamespace().pop = cwrapper.prototype("bool bool_vector_pop( bool_vector )") BoolVector.cNamespace().lshift = cwrapper.prototype("void bool_vector_lshift( bool_vector , int )")
def getNumRunning(self): return JobQueueManager.cNamespace().get_num_running( self ) def getNumComplete(self): return JobQueueManager.cNamespace().get_num_complete( self ) def isRunning(self): return JobQueueManager.cNamespace().is_running( self ) def free(self): JobQueueManager.cNamespace().free(self) def jobComplete(self , job_index): return JobQueueManager.cNamespace().job_complete( self , job_index ) ################################################################# cwrapper = CWrapper(JOB_QUEUE_LIB) cwrapper.registerObjectType("job_queue_manager", JobQueueManager) JobQueueManager.cNamespace().alloc = cwrapper.prototype("c_void_p job_queue_manager_alloc( job_queue) ") JobQueueManager.cNamespace().free = cwrapper.prototype("void job_queue_manager_free( job_queue_manager )") JobQueueManager.cNamespace().start_queue = cwrapper.prototype("void job_queue_manager_start_queue( job_queue_manager , int , bool)") JobQueueManager.cNamespace().get_num_running = cwrapper.prototype("int job_queue_manager_get_num_running( job_queue_manager )") JobQueueManager.cNamespace().get_num_complete = cwrapper.prototype("int job_queue_manager_get_num_complete( job_queue_manager )") JobQueueManager.cNamespace().is_running = cwrapper.prototype("bool job_queue_manager_is_running( job_queue_manager )") JobQueueManager.cNamespace().job_complete = cwrapper.prototype("bool job_queue_manager_job_complete( job_queue_manager , int)")
return JobQueueManager.cNamespace().get_num_complete(self) def isRunning(self): return JobQueueManager.cNamespace().is_running(self) def free(self): JobQueueManager.cNamespace().free(self) def jobComplete(self, job_index): return JobQueueManager.cNamespace().job_complete(self, job_index) ################################################################# cwrapper = CWrapper(JOB_QUEUE_LIB) cwrapper.registerObjectType("job_queue_manager", JobQueueManager) JobQueueManager.cNamespace().alloc = cwrapper.prototype( "c_void_p job_queue_manager_alloc( job_queue) ") JobQueueManager.cNamespace().free = cwrapper.prototype( "void job_queue_manager_free( job_queue_manager )") JobQueueManager.cNamespace().start_queue = cwrapper.prototype( "void job_queue_manager_start_queue( job_queue_manager , int , bool)") JobQueueManager.cNamespace().get_num_running = cwrapper.prototype( "int job_queue_manager_get_num_running( job_queue_manager )") JobQueueManager.cNamespace().get_num_complete = cwrapper.prototype( "int job_queue_manager_get_num_complete( job_queue_manager )") JobQueueManager.cNamespace().is_running = cwrapper.prototype( "bool job_queue_manager_is_running( job_queue_manager )") JobQueueManager.cNamespace().job_complete = cwrapper.prototype( "bool job_queue_manager_job_complete( job_queue_manager , int)")
if not key in self: raise KeyError("Key '%s' is not available." % key) return EclSumTStep.cNamespace().get_from_key(self, key) def __setitem__(self, key, value): if not key in self: raise KeyError("Key '%s' is not available." % key) EclSumTStep.cNamespace().set_from_key(self, key, value) def __contains__(self, key): return EclSumTStep.cNamespace().has_key(self, key) def free(self): EclSumTStep.cNamespace().free(self) cwrapper = CWrapper(ECL_LIB) cwrapper.registerObjectType("ecl_sum_tstep", EclSumTStep) EclSumTStep.cNamespace().alloc = cwrapper.prototype("void* ecl_sum_tstep_alloc_new(int, int, float, void*)") EclSumTStep.cNamespace().free = cwrapper.prototype("void ecl_sum_tstep_free(ecl_sum_tstep)") EclSumTStep.cNamespace().get_sim_days = cwrapper.prototype("double ecl_sum_tstep_get_sim_days(ecl_sum_tstep)") EclSumTStep.cNamespace().get_report = cwrapper.prototype("int ecl_sum_tstep_get_report(ecl_sum_tstep)") EclSumTStep.cNamespace().get_ministep = cwrapper.prototype("int ecl_sum_tstep_get_ministep(ecl_sum_tstep)") EclSumTStep.cNamespace().set_from_key = cwrapper.prototype("void ecl_sum_tstep_set_from_key(ecl_sum_tstep, char*, float)") EclSumTStep.cNamespace().get_from_key = cwrapper.prototype("double ecl_sum_tstep_get_from_key(ecl_sum_tstep, char*)") EclSumTStep.cNamespace().has_key = cwrapper.prototype("bool ecl_sum_tstep_has_key(ecl_sum_tstep)")
if isinstance(value, float): DoubleHash.cNamespace().insert_double(self, key, value) else: raise ValueError("DoubleHash does not support type: %s" % value.__class__) def __getitem__(self, key): if key in self: return DoubleHash.cNamespace().get_double(self, key) else: raise KeyError("Hash does not have key: %s" % key) cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("hash", Hash) # c_void_p type CWrapper.registerObjectType("integer_hash", IntegerHash) CWrapper.registerObjectType("string_hash", StringHash) CWrapper.registerObjectType("double_hash", DoubleHash) Hash.cNamespace().alloc = cwrapper.prototype("long hash_alloc()") Hash.cNamespace().free = cwrapper.prototype("void hash_free(hash)") Hash.cNamespace().size = cwrapper.prototype("int hash_get_size(hash)") Hash.cNamespace().keys = cwrapper.prototype( "stringlist_obj hash_alloc_stringlist(hash)") Hash.cNamespace().has_key = cwrapper.prototype( "bool hash_has_key(hash, char*)") Hash.cNamespace().get = cwrapper.prototype("c_void_p hash_get(hash, char*)") IntegerHash.cNamespace().get_int = cwrapper.prototype( "int hash_get_int(hash, char*)")
def free(self): JobQueue.cNamespace().free(self) def __len__(self): return self.cNamespace().get_active_size(self) def getJobStatus(self, job_number): """ @rtype: JobStatusType """ return self.cNamespace().get_job_status(self, job_number) ################################################################# cwrapper = CWrapper(JOB_QUEUE_LIB) cwrapper.registerObjectType("job_queue", JobQueue) JobQueue.cNamespace().alloc = cwrapper.prototype( "c_void_p job_queue_alloc( int , char* , char* )") JobQueue.cNamespace().user_exit = cwrapper.prototype( "void job_queue_user_exit( job_queue )") JobQueue.cNamespace().free = cwrapper.prototype( "void job_queue_free( job_queue )") JobQueue.cNamespace().set_max_running = cwrapper.prototype( "void job_queue_set_max_running( job_queue , int)") JobQueue.cNamespace().get_max_running = cwrapper.prototype( "int job_queue_get_max_running( job_queue )") JobQueue.cNamespace().set_driver = cwrapper.prototype( "void job_queue_set_driver( job_queue , c_void_p )") JobQueue.cNamespace().add_job = cwrapper.prototype( "int job_queue_add_job( job_queue , char* , c_void_p , c_void_p , c_void_p , c_void_p , int , char* , char* , int , char**)"
def igetMean(self , iobs): if 0 <= iobs < self.getObsSize(): return MeasBlock.cNamespace().iget_mean(self , iobs) else: raise IndexError("Invalid observation index:%d valid range: [0,%d)" % (iobs , self.getObsSize())) def igetStd(self , iobs): if 0 <= iobs < self.getObsSize(): return MeasBlock.cNamespace().iget_std(self , iobs) else: raise IndexError("Invalid observation index:%d valid range: [0,%d)" % (iobs , self.getObsSize())) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("meas_block", MeasBlock) MeasBlock.cNamespace().alloc = cwrapper.prototype("c_void_p meas_block_alloc( char* , bool_vector , int)") MeasBlock.cNamespace().free = cwrapper.prototype("void meas_block_free( meas_block )") MeasBlock.cNamespace().get_active_ens_size = cwrapper.prototype("int meas_block_get_active_ens_size( meas_block )") MeasBlock.cNamespace().get_total_ens_size = cwrapper.prototype("int meas_block_get_total_ens_size( meas_block )") MeasBlock.cNamespace().get_total_obs_size = cwrapper.prototype("int meas_block_get_total_obs_size( meas_block )") MeasBlock.cNamespace().iget_value = cwrapper.prototype("double meas_block_iget( meas_block , int , int)") MeasBlock.cNamespace().iset_value = cwrapper.prototype("void meas_block_iset( meas_block , int , int , double)") MeasBlock.cNamespace().iget_mean = cwrapper.prototype("double meas_block_iget_ens_mean( meas_block , int )") MeasBlock.cNamespace().iget_std = cwrapper.prototype("double meas_block_iget_ens_std( meas_block , int )") MeasBlock.cNamespace().iens_active = cwrapper.prototype("bool meas_block_iens_active( meas_block , int )")
def getData(self, state, obs_index, node_id): """ @type state: c_void_p @type obs_index: int @type node_id: NodeId @rtype: float """ return BlockObservation.cNamespace().iget_data(self, state, obs_index, node_id) def free(self): BlockObservation.cNamespace().free(self) ################################################################## cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("block_obs", BlockObservation) BlockObservation.cNamespace().free = cwrapper.prototype("void block_obs_free( block_obs )") BlockObservation.cNamespace().iget_i = cwrapper.prototype("int block_obs_iget_i(block_obs, int)") BlockObservation.cNamespace().iget_j = cwrapper.prototype("int block_obs_iget_j( block_obs, int)") BlockObservation.cNamespace().iget_k = cwrapper.prototype("int block_obs_iget_k( block_obs , int)") BlockObservation.cNamespace().get_size = cwrapper.prototype("int block_obs_get_size( block_obs )") BlockObservation.cNamespace().get_std = cwrapper.prototype("double block_obs_iget_std( block_obs, int )") BlockObservation.cNamespace().get_value = cwrapper.prototype("double block_obs_iget_value( block_obs, int)") BlockObservation.cNamespace().get_depth = cwrapper.prototype("double block_obs_iget_depth( block_obs, int)") BlockObservation.cNamespace().iget_data = cwrapper.prototype("double block_obs_iget_data(block_obs, c_void_p, int, node_id)")
return self.__test_context def __exit__(self, exc_type, exc_val, exc_tb): del self.__test_context return False def getErt(self): return self.__test_context.getErt() def getCwd(self): """ Returns the current working directory of this context. @rtype: string """ return self.__test_context.getCwd() cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType("ert_test", ErtTest) ErtTest.cNamespace().alloc = cwrapper.prototype( "c_void_p ert_test_context_alloc_python( char* , char* , char*)") ErtTest.cNamespace().set_store = cwrapper.prototype( "c_void_p ert_test_context_set_store( ert_test , bool)") ErtTest.cNamespace().free = cwrapper.prototype( "void ert_test_context_free( ert_test )") ErtTest.cNamespace().get_enkf_main = cwrapper.prototype( "enkf_main_ref ert_test_context_get_main( ert_test )") ErtTest.cNamespace().get_cwd = cwrapper.prototype( "char* ert_test_context_get_cwd( ert_test )")
characters the returned active list will be empty: "1,4-7,10" => {1,4,5,6,7,10} "1,4-7,10X" => {} The empty list will evaluate to false """ return cls.cNamespace().create_active_list(range_string) def count(self, value): """ @rtype: int """ return IntVector.cNamespace().count_equal(self, value) cwrapper = CWrapper(UTIL_LIB) CWrapper.registerObjectType("int_vector", IntVector) IntVector.cNamespace().alloc = cwrapper.prototype( "c_void_p int_vector_alloc( int , int )") IntVector.cNamespace().alloc_copy = cwrapper.prototype( "int_vector_obj int_vector_alloc_copy( int_vector )") IntVector.cNamespace().strided_copy = cwrapper.prototype( "int_vector_obj int_vector_alloc_strided_copy( int_vector , int , int , int)" ) IntVector.cNamespace().free = cwrapper.prototype( "void int_vector_free( int_vector )") IntVector.cNamespace().iget = cwrapper.prototype( "int int_vector_iget( int_vector , int )") IntVector.cNamespace().safe_iget = cwrapper.prototype( "int int_vector_safe_iget( int_vector , int )") IntVector.cNamespace().iset = cwrapper.prototype(