def test_method_type(self): wrapper = CWrapper(test_lib) def stringObj(c_ptr): char_ptr = ctypes.c_char_p( c_ptr ) python_string = char_ptr.value test_lib.free(c_ptr) return python_string wrapper.registerType("string_obj", stringObj) dateStamp = wrapper.prototype("string_obj util_alloc_date_stamp_utc()") date_stamp = dateStamp() self.assertIsInstance(date_stamp, str)
Will add a key -> value pair which can be used for search replace operations in the data file. Observe that the key will be surrounded by \'<\' and \'>\'. """ doc_string = None if isinstance(value , str): EnKFState.cNamespace().add_subst_kw( self , key , value , doc_string ) else: raise TypeError("The value argument must be a string") def getDataKW(self): """ Will return the substitution map for this realisation. """ return EnKFState.cNamespace().get_subst_list( self ) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("enkf_state", EnKFState) cwrapper.registerType("enkf_state_obj", EnKFState.createPythonObject) cwrapper.registerType("enkf_state_ref", EnKFState.createCReference) EnKFState.cNamespace().free = cwrapper.prototype("void enkf_state_free( enkf_state )") EnKFState.cNamespace().has_key = cwrapper.prototype("bool enkf_state_has_node( enkf_state , char* )") EnKFState.cNamespace().get_node = cwrapper.prototype("enkf_node_ref enkf_state_get_node( enkf_state , char* )") EnKFState.cNamespace().add_subst_kw = cwrapper.prototype("void enkf_state_add_subst_kw( enkf_state , char* , char* , char*)") EnKFState.cNamespace().get_subst_list = cwrapper.prototype("subst_list_ref enkf_state_get_subst_list( enkf_state )")
return PcaPlotData.cNamespace().get(self, index).setParent(self) def __iter__(self): cur = 0 while cur < len(self): yield self[cur] cur += 1 def getSingularValues(self): """ @rtype: DoubleVector """ return PcaPlotData.cNamespace().get_singular_values(self).setParent(self) def free(self): PcaPlotData.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("pca_plot_data", PcaPlotData) cwrapper.registerType("pca_plot_data_obj", PcaPlotData.createPythonObject) cwrapper.registerType("pca_plot_data_ref", PcaPlotData.createCReference) PcaPlotData.cNamespace().alloc = cwrapper.prototype("c_void_p pca_plot_data_alloc(char*, matrix, matrix , double_vector)") PcaPlotData.cNamespace().free = cwrapper.prototype("void pca_plot_data_free(pca_plot_data)") PcaPlotData.cNamespace().component_count = cwrapper.prototype("int pca_plot_data_get_size(pca_plot_data)") PcaPlotData.cNamespace().realization_count = cwrapper.prototype("int pca_plot_data_get_ens_size(pca_plot_data)") PcaPlotData.cNamespace().get = cwrapper.prototype("pca_plot_vector_ref pca_plot_data_iget_vector(pca_plot_data, int)") PcaPlotData.cNamespace().get_name = cwrapper.prototype("char* pca_plot_data_get_name(pca_plot_data)") PcaPlotData.cNamespace().get_singular_values = cwrapper.prototype("double_vector_ref pca_plot_data_get_singular_values(pca_plot_data)")
class SchedFile(BaseCClass): def __init__(self, filename, start_time): if os.path.isfile(filename): c_ptr = SchedFile.cNamespace().parse(filename, CTime(start_time)) super(SchedFile, self).__init__(c_ptr) else: raise IOError("No such file: %s" % filename) @property def length(self): """ @rtype: int """ return SchedFile.cNamespace().length(self) def write(self, filename, num_dates, add_end=True): SchedFile.cNamespace().write(self, num_dates, filename, add_end) def free(self): SchedFile.cNamespace().free(self) cwrapper = CWrapper(SCHED_LIB) cwrapper.registerType("sched_file", SchedFile) cwrapper.registerType("sched_file_obj", SchedFile.createPythonObject) cwrapper.registerType("sched_file_ref", SchedFile.createCReference) SchedFile.cNamespace().parse = cwrapper.prototype("c_void_p sched_file_parse_alloc( char*, time_t )") SchedFile.cNamespace().write = cwrapper.prototype("void sched_file_fprintf_i( sched_file , int , char* , bool)") SchedFile.cNamespace().length = cwrapper.prototype("int sched_file_get_num_restart_files( sched_file )") SchedFile.cNamespace().free = cwrapper.prototype("void sched_file_free( sched_file )")
def getTemplateNames(self): """ @rtype: StringList """ return ErtTemplates.cNamespace().alloc_list(self).setParent(self) def clear(self): ErtTemplates.cNamespace().clear(self) def get_template(self, key): """ @rtype: ErtTemplate """ return ErtTemplates.cNamespace().get_template(self, key).setParent(self) def add_template(self, key, template_file, target_file, arg_string): """ @rtype: ErtTemplate """ return ErtTemplates.cNamespace().add_template(self, key, template_file, target_file, arg_string).setParent(self) def free(self): ErtTemplates.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ert_templates", ErtTemplates) cwrapper.registerType("ert_templates_obj", ErtTemplates.createPythonObject) cwrapper.registerType("ert_templates_ref", ErtTemplates.createCReference) ErtTemplates.cNamespace().free = cwrapper.prototype("void ert_templates_free( ert_templates )") ErtTemplates.cNamespace().alloc_list = cwrapper.prototype("stringlist_ref ert_templates_alloc_list(ert_templates)") ErtTemplates.cNamespace().get_template = cwrapper.prototype("ert_template_ref ert_templates_get_template(ert_templates, char*)") ErtTemplates.cNamespace().clear = cwrapper.prototype("void ert_templates_clear(ert_templates)") ErtTemplates.cNamespace().add_template = cwrapper.prototype("ert_template_ref ert_templates_add_template(ert_templates, char*, char*, char*, char*)")
# Copyright (C) 2012 Statoil ASA, Norway. # # The file 'field_config.py' is part of ERT - Ensemble based Reservoir Tool. # # ERT is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # ERT is distributed in the hope that it will be useful, but WITHOUT ANY # WARRANTY; without even the implied warranty of MERCHANTABILITY or # FITNESS FOR A PARTICULAR PURPOSE. # # See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> # for more details. from cwrap import BaseCClass, CWrapper from ert.enkf import ENKF_LIB class SummaryConfig(BaseCClass): def __init__(self): raise NotImplementedError("Class can not be instantiated directly!") cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("summary_config", SummaryConfig) cwrapper.registerType("summary_config", SummaryConfig.createPythonObject) cwrapper.registerType("summary_config", SummaryConfig.createCReference)
""" @rtype: float """ return len(self) def getIndex(self, obs_index): """ @rtype: int """ return self.getDataIndex(obs_index) def getDataIndex(self, obs_index): return GenObservation.cNamespace().get_data_index(self, obs_index) def free(self): GenObservation.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("gen_obs", GenObservation) cwrapper.registerType("gen_obs_obj", GenObservation.createPythonObject) cwrapper.registerType("gen_obs_ref", GenObservation.createCReference) GenObservation.cNamespace().alloc = cwrapper.prototype( "c_void_p gen_obs_alloc__(gen_data_config , char*)") GenObservation.cNamespace().free = cwrapper.prototype( "void gen_obs_free(gen_data_config)") GenObservation.cNamespace().load = cwrapper.prototype( "void gen_obs_load_observation(gen_obs , char*)") GenObservation.cNamespace().scalar_set = cwrapper.prototype( "void gen_obs_set_scalar(gen_obs , double , double)") GenObservation.cNamespace().get_value = cwrapper.prototype( "double gen_obs_iget_value(summary_obs)") GenObservation.cNamespace().get_std_scaling = cwrapper.prototype( "double gen_obs_iget_std_scaling(summary_obs)")
""" @type refcase: EclSum @type use_history: bool @rtype: HistoryType """ return History.cNamespace().alloc_from_refcase(refcase, use_history) @staticmethod def alloc_from_sched_file(sched_file): """ @rtype: HistoryType """ assert isinstance(sched_file, SchedFile) return History.cNamespace().alloc_from_sched_file(":", sched_file) def free(self): History.cNamespace().free(self) cwrapper = CWrapper(SCHED_LIB) cwrapper.registerType("history", History) cwrapper.registerType("history_obj", History.createPythonObject) cwrapper.registerType("history_ref", History.createCReference) History.cNamespace().free = cwrapper.prototype("void history_free( history )") History.cNamespace().get_source_string = cwrapper.prototype("char* history_get_source_string(history_source_enum)") History.cNamespace().alloc_from_refcase = cwrapper.prototype("history_obj history_alloc_from_refcase(ecl_sum, bool)") History.cNamespace().alloc_from_sched_file = cwrapper.prototype("history_obj history_alloc_from_sched_file(char*, sched_file)") # History.cNamespace().history_get_source_type = cwrapper.prototype("history_source_type_enum history_get_source_type(char*)")
return len(self) def getIndex(self, obs_index): """ @rtype: int """ return self.getDataIndex( obs_index ) def getDataIndex(self, obs_index): return GenObservation.cNamespace().get_data_index(self, obs_index) def free(self): GenObservation.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("gen_obs", GenObservation) cwrapper.registerType("gen_obs_obj", GenObservation.createPythonObject) cwrapper.registerType("gen_obs_ref", GenObservation.createCReference) GenObservation.cNamespace().alloc = cwrapper.prototype("c_void_p gen_obs_alloc__(gen_data_config , char*)") GenObservation.cNamespace().free = cwrapper.prototype("void gen_obs_free(gen_data_config)") GenObservation.cNamespace().load = cwrapper.prototype("void gen_obs_load_observation(gen_obs , char*)") GenObservation.cNamespace().scalar_set = cwrapper.prototype("void gen_obs_set_scalar(gen_obs , double , double)") GenObservation.cNamespace().get_value = cwrapper.prototype("double gen_obs_iget_value(summary_obs)") GenObservation.cNamespace().get_std_scaling = cwrapper.prototype("double gen_obs_iget_std_scaling(summary_obs)") GenObservation.cNamespace().get_std = cwrapper.prototype("double gen_obs_iget_std(gen_obs, int)") GenObservation.cNamespace().get_size = cwrapper.prototype("int gen_obs_get_size(gen_obs)") GenObservation.cNamespace().get_data_index = cwrapper.prototype("int gen_obs_get_obs_index(gen_obs, int)") GenObservation.cNamespace().load_data_index = cwrapper.prototype("void gen_obs_load_data_index(gen_obs , char*)") GenObservation.cNamespace().add_data_index = cwrapper.prototype("void gen_obs_attach_data_index(gen_obs , int_vector)") GenObservation.cNamespace().update_std_scaling = cwrapper.prototype("void gen_obs_update_std_scale(gen_obs , double , active_list)")
from ctypes import Structure, c_int from cwrap import CWrapper class NodeId(Structure): """ NodeId is specified in enkf_types.h """ _fields_ = [("report_step", c_int), ("iens", c_int)] def __init__(self, report_step, realization_number): """ @type report_step: int @type realization_number: int """ super(NodeId, self).__init__(report_step, realization_number) CWrapper.registerType("node_id", NodeId)
def __init__(self): raise NotImplementedError("Class can not be instantiated directly!") def __len__(self): """ @rtype: int """ return EnsemblePlotDataVector.cNamespace().size(self) def getValue(self, index): """ @rtype: float """ return EnsemblePlotDataVector.cNamespace().get_value(self, index) def getTime(self, index): """ @rtype: CTime """ return EnsemblePlotDataVector.cNamespace().get_time(self, index) def isActive(self, index): """ @rtype: bool """ return EnsemblePlotDataVector.cNamespace().is_active(self, index) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ensemble_plot_data_vector", EnsemblePlotDataVector) cwrapper.registerType("ensemble_plot_data_vector_obj", EnsemblePlotDataVector.createPythonObject) cwrapper.registerType("ensemble_plot_data_vector_ref", EnsemblePlotDataVector.createCReference) EnsemblePlotDataVector.cNamespace().size = cwrapper.prototype("int enkf_plot_tvector_size(ensemble_plot_data_vector)") EnsemblePlotDataVector.cNamespace().get_value = cwrapper.prototype("double enkf_plot_tvector_iget_value(ensemble_plot_data_vector, int)") EnsemblePlotDataVector.cNamespace().get_time = cwrapper.prototype("time_t enkf_plot_tvector_iget_time(ensemble_plot_data_vector, int)") EnsemblePlotDataVector.cNamespace().is_active = cwrapper.prototype("bool enkf_plot_tvector_iget_active(ensemble_plot_data_vector, int)")
def __len__(self): """ @rtype: int """ return EnsemblePlotGenKWVector.cNamespace().size(self) def getValue(self, index): """ @rtype: float """ return self[index] def __iter__(self): cur = 0 while cur < len(self): yield self[cur] cur += 1 def __getitem__(self, index): """ @rtype: float """ return EnsemblePlotGenKWVector.cNamespace().get_value(self, index) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ensemble_plot_gen_kw_vector", EnsemblePlotGenKWVector) cwrapper.registerType("ensemble_plot_gen_kw_vector_obj", EnsemblePlotGenKWVector.createPythonObject) cwrapper.registerType("ensemble_plot_gen_kw_vector_ref", EnsemblePlotGenKWVector.createCReference) EnsemblePlotGenKWVector.cNamespace().size = cwrapper.prototype("int enkf_plot_gen_kw_vector_get_size(ensemble_plot_gen_kw_vector)") EnsemblePlotGenKWVector.cNamespace().get_value = cwrapper.prototype("double enkf_plot_gen_kw_vector_iget(ensemble_plot_gen_kw_vector, int)")
# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> # for more details. from cwrap import BaseCClass, CWrapper from ert.enkf import ENKF_LIB class PlotConfig(BaseCClass): def __init__(self): raise NotImplementedError("Class can not be instantiated directly!") def getPath(self): """ @rtype: str """ return PlotConfig.cNamespace().get_path(self) def setPath(self, path): PlotConfig.cNamespace().set_path(self, path) def free(self): PlotConfig.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("plot_config", PlotConfig) cwrapper.registerType("plot_config_obj", PlotConfig.createPythonObject) cwrapper.registerType("plot_config_ref", PlotConfig.createCReference) PlotConfig.cNamespace().free = cwrapper.prototype("void plot_config_free( plot_config )") PlotConfig.cNamespace().get_path = cwrapper.prototype("char* plot_config_get_path(plot_config)") PlotConfig.cNamespace().set_path = cwrapper.prototype("void plot_config_set_path(plot_config, char*)")
for step,t in enumerate(self): step_list.append( (step , t , self.getSimulationDays( step )) ) return step_list def getLastStep(self): return TimeMap.cNamespace().last_step(self) def upgrade107(self, refcase): TimeMap.cNamespace().upgrade107(self, refcase) ################################################################## cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("time_map", TimeMap) cwrapper.registerType("time_map_obj", TimeMap.createPythonObject) cwrapper.registerType("time_map_ref", TimeMap.createCReference) ################################################################## ################################################################## TimeMap.cNamespace().free = cwrapper.prototype("void time_map_free( time_map )") TimeMap.cNamespace().fread_alloc_readonly = cwrapper.prototype("c_void_p time_map_fread_alloc_readonly(char*)") TimeMap.cNamespace().alloc = cwrapper.prototype("c_void_p time_map_alloc()") TimeMap.cNamespace().load = cwrapper.prototype("bool time_map_fread(time_map , char*)") TimeMap.cNamespace().save = cwrapper.prototype("void time_map_fwrite(time_map , char*)") TimeMap.cNamespace().fload = cwrapper.prototype("bool time_map_fscanf(time_map , char*)") TimeMap.cNamespace().iget_sim_days = cwrapper.prototype("double time_map_iget_sim_days(time_map, int)") TimeMap.cNamespace().iget = cwrapper.prototype("time_t time_map_iget(time_map, int)")
# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html> # for more details. """ Create a polygon """ from cwrap import CClass, CWrapper, CWrapperNameSpace from ert.geo import ERT_GEOMETRY_LIB class GeoPolygon(CClass): def __init__(self, points): c_ptr = cfunc.alloc_new() self.init_cobj(c_ptr, cfunc.free) for (xc, yc) in points: self.add_point(xc, yc) def add_point( self, xc, yc ): cfunc.add_point(self, xc, yc) ################################################################# cwrapper = CWrapper(ERT_GEOMETRY_LIB) cwrapper.registerType("geo_polygon", GeoPolygon) cfunc = CWrapperNameSpace("geo_polygon") cfunc.alloc_new = cwrapper.prototype("c_void_p geo_polygon_alloc( )") cfunc.add_point = cwrapper.prototype("void geo_polygon_add_point( geo_polygon , double , double )") cfunc.free = cwrapper.prototype("void geo_polygon_free( geo_polygon )")
host_list = SiteConfig.cNamespace().get_rsh_host_list(self) return host_list def addRshHost(self, host, max_running): SiteConfig.cNamespace().add_rsh_host(self, host, max_running) def getLocation(self): """ @rtype: str """ return SiteConfig.cNamespace().get_location(self) def free(self): SiteConfig.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("site_config", SiteConfig) cwrapper.registerType("site_config_obj", SiteConfig.createPythonObject) cwrapper.registerType("site_config_ref", SiteConfig.createCReference) SiteConfig.cNamespace().free = cwrapper.prototype("void site_config_free( site_config )") SiteConfig.cNamespace().get_queue_name = cwrapper.prototype("char* site_config_get_queue_name(site_config)") SiteConfig.cNamespace().get_lsf_queue = cwrapper.prototype("char* site_config_get_lsf_queue(site_config)") SiteConfig.cNamespace().set_lsf_queue = cwrapper.prototype("void site_config_set_lsf_queue(site_config, char*)") SiteConfig.cNamespace().get_max_running_lsf = cwrapper.prototype("int site_config_get_max_running_lsf(site_config)") SiteConfig.cNamespace().set_max_running_lsf = cwrapper.prototype( "void site_config_set_max_running_lsf(site_config, int)" ) SiteConfig.cNamespace().get_lsf_request = cwrapper.prototype("char* site_config_get_lsf_request(site_config)") SiteConfig.cNamespace().set_lsf_request = cwrapper.prototype("void site_config_set_lsf_request(site_config, char*)")
def getMaxValues(self): """ @rtype: DoubleVector """ return EnsemblePlotGenData.cNamespace().max_values(self).setParent(self) def getMinValues(self): """ @rtype: DoubleVector """ return EnsemblePlotGenData.cNamespace().min_values(self).setParent(self) def free(self): EnsemblePlotGenData.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ensemble_plot_gen_data", EnsemblePlotGenData) cwrapper.registerType("ensemble_plot_gen_data_obj", EnsemblePlotGenData.createPythonObject) cwrapper.registerType("ensemble_plot_gen_data_ref", EnsemblePlotGenData.createCReference) EnsemblePlotGenData.cNamespace().free = cwrapper.prototype("void enkf_plot_gendata_free(ensemble_plot_gen_data)") EnsemblePlotGenData.cNamespace().alloc = cwrapper.prototype("c_void_p enkf_plot_gendata_alloc(enkf_config_node)") EnsemblePlotGenData.cNamespace().size = cwrapper.prototype("int enkf_plot_gendata_get_size(ensemble_plot_gen_data)") EnsemblePlotGenData.cNamespace().load = cwrapper.prototype("void enkf_plot_gendata_load(ensemble_plot_gen_data, enkf_fs, int, bool_vector)") EnsemblePlotGenData.cNamespace().get = cwrapper.prototype("ensemble_plot_gen_data_vector_ref enkf_plot_gendata_iget(ensemble_plot_gen_data, int)") EnsemblePlotGenData.cNamespace().min_values = cwrapper.prototype("double_vector_ref enkf_plot_gendata_get_min_values(ensemble_plot_gen_data)") EnsemblePlotGenData.cNamespace().max_values = cwrapper.prototype("double_vector_ref enkf_plot_gendata_get_max_values(ensemble_plot_gen_data)")
kw = self.getKeyWordForIndex(index) if kw == keyword: return index return None def shouldUseLogScale(self, index): """ @rtype: bool """ return bool(EnsemblePlotGenKW.cNamespace().should_use_log_scale(self, index)) def free(self): EnsemblePlotGenKW.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ensemble_plot_gen_kw", EnsemblePlotGenKW) cwrapper.registerType("ensemble_plot_gen_kw_obj", EnsemblePlotGenKW.createPythonObject) cwrapper.registerType("ensemble_plot_gen_kw_ref", EnsemblePlotGenKW.createCReference) EnsemblePlotGenKW.cNamespace().free = cwrapper.prototype("void enkf_plot_gen_kw_free(ensemble_plot_gen_kw)") EnsemblePlotGenKW.cNamespace().alloc = cwrapper.prototype("c_void_p enkf_plot_gen_kw_alloc(enkf_config_node)") EnsemblePlotGenKW.cNamespace().size = cwrapper.prototype("int enkf_plot_gen_kw_get_size(ensemble_plot_gen_kw)") EnsemblePlotGenKW.cNamespace().load = cwrapper.prototype("void enkf_plot_gen_kw_load(ensemble_plot_gen_kw, enkf_fs, bool, int, bool_vector)") EnsemblePlotGenKW.cNamespace().get = cwrapper.prototype("ensemble_plot_gen_kw_vector_ref enkf_plot_gen_kw_iget(ensemble_plot_gen_kw, int)") EnsemblePlotGenKW.cNamespace().iget_key = cwrapper.prototype("char* enkf_plot_gen_kw_iget_key(ensemble_plot_gen_kw, int)") EnsemblePlotGenKW.cNamespace().get_keyword_count = cwrapper.prototype("int enkf_plot_gen_kw_get_keyword_count(ensemble_plot_gen_kw)") EnsemblePlotGenKW.cNamespace().should_use_log_scale = cwrapper.prototype("bool enkf_plot_gen_kw_should_use_log_scale(ensemble_plot_gen_kw, int)")
cur = 0 while cur < len(self): yield self[cur] cur += 1 def getObservation(self): """ @rtype: float """ return PcaPlotVector.cNamespace().get_obs(self) def getSingularValue(self): """ @rtype: float """ return PcaPlotVector.cNamespace().get_singular_value(self) def free(self): PcaPlotVector.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("pca_plot_vector", PcaPlotVector) cwrapper.registerType("pca_plot_vector_obj", PcaPlotVector.createPythonObject) cwrapper.registerType("pca_plot_vector_ref", PcaPlotVector.createCReference) PcaPlotVector.cNamespace().alloc = cwrapper.prototype("c_void_p pca_plot_vector_alloc(int, matrix, matrix)") PcaPlotVector.cNamespace().free = cwrapper.prototype("void pca_plot_vector_free(pca_plot_vector)") PcaPlotVector.cNamespace().size = cwrapper.prototype("int pca_plot_vector_get_size(pca_plot_vector)") PcaPlotVector.cNamespace().get = cwrapper.prototype("double pca_plot_vector_iget_sim_value(pca_plot_vector, int)") PcaPlotVector.cNamespace().get_obs = cwrapper.prototype("double pca_plot_vector_get_obs_value(pca_plot_vector)") PcaPlotVector.cNamespace().get_singular_value = cwrapper.prototype( "double pca_plot_vector_get_singular_value(pca_plot_vector)" )
EclConfig.cNamespace().clear_static_kw(self) def add_static_kw(self, kw): EclConfig.cNamespace().add_static_kw(self, kw) #----------------------------------------------------------------- def getDepthUnit(self): return EclConfig.cNamespace().get_depth_unit(self) def getPressureUnit(self): return EclConfig.cNamespace().get_pressure_unit(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerType("ecl_config", EclConfig) cwrapper.registerType("ecl_config_obj", EclConfig.createPythonObject) cwrapper.registerType("ecl_config_ref", EclConfig.createCReference) EclConfig.cNamespace().alloc = cwrapper.prototype("c_void_p ecl_config_alloc( )") EclConfig.cNamespace().free = cwrapper.prototype("void ecl_config_free( ecl_config )") EclConfig.cNamespace().get_eclbase = cwrapper.prototype("char* ecl_config_get_eclbase( ecl_config )") EclConfig.cNamespace().validate_eclbase = cwrapper.prototype("ui_return_obj ecl_config_validate_eclbase( ecl_config , char*)") EclConfig.cNamespace().set_eclbase = cwrapper.prototype("void ecl_config_set_eclbase( ecl_config , char*)") EclConfig.cNamespace().get_data_file = cwrapper.prototype("char* ecl_config_get_data_file(ecl_config)") EclConfig.cNamespace().set_data_file = cwrapper.prototype("void ecl_config_set_data_file(ecl_config , char*)") EclConfig.cNamespace().validate_data_file = cwrapper.prototype("ui_return_obj ecl_config_validate_data_file(ecl_config , char*)")