def __init__(self, ert, function_name, argument_types, argument_count):
super(FunctionErtScript, self).__init__(ert)
lib = clib.ert_load(None)
wrapper = CWrapper(lib)
parsed_argument_types = []
if ert is not None:
self.__function = wrapper.prototype("c_void_p %s(c_void_p, stringlist)" % function_name)
else:
for arg in argument_types:
if arg is bool:
parsed_argument_types.append("bool")
elif arg is str:
parsed_argument_types.append("char*")
elif arg is int:
parsed_argument_types.append("int")
elif arg is float:
parsed_argument_types.append("float")
else:
raise TypeError("Unknown type: %s" % arg)
self.__function = wrapper.prototype("c_void_p %s(%s)" % (function_name, ", ".join(parsed_argument_types[:argument_count])))
def setUp(self):
ert = clib.ert_load("libert_util")
self.ert_wrapper = CWrapper(ert)
self.ert_wrapper.registerType("pow_double", MaxDouble)
self.double_max = self.ert_wrapper.prototype(
"pow_double util_double_max(double, double)")
def setUp(self):
ert = clib.ert_load("libert_util")
self.ert_wrapper = CWrapper(ert)
self.ert_wrapper.registerType("time_t", TimeTValue)
self.make_date = self.ert_wrapper.prototype(
"time_t util_make_date(int, int, int)")
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 )")
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()
v[0] = 1
return kw_copy
else:
raise ValueError(
"The input keyword must have nx*n*nz or nactive elements. Size:%d invalid"
% len(kw))
def exportACTNUMKw(self):
actnum = EclKW.create("ACTNUM", self.getGlobalSize(),
EclTypeEnum.ECL_INT_TYPE)
cfunc.init_actnum(self, actnum.getDataPtr())
return actnum
# 2. Creating a wrapper object around the libecl library,
# registering the type map : ecl_kw <-> EclKW
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType("ecl_grid", EclGrid)
# 3. Installing the c-functions used to manipulate ecl_kw instances.
# These functions are used when implementing the EclKW class, not
# used outside this scope.
cfunc = CWrapperNameSpace("ecl_grid")
cfunc.fread_alloc = cwrapper.prototype("c_void_p ecl_grid_load_case( char* )")
cfunc.grdecl_create = cwrapper.prototype(
"c_void_p ecl_grid_alloc_GRDECL_kw( int , int , int , ecl_kw , ecl_kw , ecl_kw , ecl_kw)"
)
cfunc.get_lgr = cwrapper.prototype(
"c_void_p ecl_grid_get_lgr( ecl_grid , char* )")
cfunc.get_cell_lgr = cwrapper.prototype(
"c_void_p ecl_grid_get_cell_lgr1( ecl_grid , int )")
from ert.cwrap import clib, CWrapper
from ert.enkf.data import EnkfNode
from ert.enkf.config import GenDataConfig
from ert.enkf import NodeId
from ert.enkf import ForwardLoadContext
from ert.test import ErtTestContext, ExtendedTestCase
from ert.util import BoolVector
test_lib = clib.ert_load("libenkf")
cwrapper = CWrapper(test_lib)
get_active_mask = cwrapper.prototype("bool_vector_ref gen_data_config_get_active_mask( gen_data_config )")
update_active_mask = cwrapper.prototype("void gen_data_config_update_active( gen_data_config, forward_load_context , bool_vector)")
alloc_run_arg = cwrapper.prototype("run_arg_obj run_arg_alloc_ENSEMBLE_EXPERIMENT( enkf_fs , int , int , char*) ")
def updateMask(gen_data_config , report_step , fs, active_mask):
run_arg = alloc_run_arg( fs , 0 , 0 , "Path")
load_context = ForwardLoadContext( run_arg = run_arg , report_step = report_step )
update_active_mask( gen_data_config , load_context , active_mask )
class GenDataConfigTest(ExtendedTestCase):
def setUp(self):
self.config_file = self.createTestPath("Statoil/config/with_GEN_DATA/config")
def load_active_masks(self, case1, case2 ):
with ErtTestContext("gen_data_config_test", self.config_file) as test_context:
ert = test_context.getErt()
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(
# See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
# for more details.
"""
Create a polygon
"""
from ert.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 )")
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 )")
def registerEnum(cls, library, enum_name):
cwrapper = CWrapper(library)
cwrapper.registerType(enum_name, cls)
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 )")
self.setValue(self.value() + CTime(other).value())
return self
def __add__(self, other):
copy = CTime(self)
copy += other
return copy
def __radd__(self, other):
return self + other
def __mul__(self, other):
copy = CTime(self)
copy *= other
return copy
def __rmul__(self, other):
return self * other
def timetuple(self):
# this function is a requirement for comparing against datetime objects where the CTime is on the right side
pass
@property
def stripped(self):
return time.strptime(self, "%Y-%m-%d %H:%M:S%")
cwrapper = CWrapper(None)
cwrapper.registerType("time_t", CTime)
test = AnalysisModule.cNamespace().get_str(self, var)
return str(test)
def initUpdate(self, mask, S, R, dObs, E, D):
print "Running initUpdate"
AnalysisModule.cNamespace().init_update(self, mask, S, R, dObs, E, D)
def updateA(self, A, S, R, dObs, E, D):
print "Running updateA"
AnalysisModule.cNamespace().updateA(self, A, S, R, dObs, E, D)
def initX(self, X, A, S, R, dObs, E, D):
AnalysisModule.cNamespace().init_update(self, X, A, S, R, dObs, E, D)
cwrapper = CWrapper(ANALYSIS_LIB)
cwrapper.registerObjectType("analysis_module", AnalysisModule)
AnalysisModule.cNamespace().alloc_external = cwrapper.prototype(
"c_void_p analysis_module_alloc_external(rng, char*, char*)")
AnalysisModule.cNamespace().free = cwrapper.prototype(
"void analysis_module_free(analysis_module)")
AnalysisModule.cNamespace().get_lib_name = cwrapper.prototype(
"char* analysis_module_get_lib_name(analysis_module)")
AnalysisModule.cNamespace().get_module_internal = cwrapper.prototype(
"bool analysis_module_internal(analysis_module)")
AnalysisModule.cNamespace().set_var = cwrapper.prototype(
"bool analysis_module_set_var(analysis_module, char*, char*)")
AnalysisModule.cNamespace().get_table_name = cwrapper.prototype(
"char* analysis_module_get_table_name(analysis_module)")
AnalysisModule.cNamespace().get_name = cwrapper.prototype(
import ctypes
from ert.cwrap import clib, CWrapper
from ert.ecl import EclKW, EclFile, EclTypeEnum, FortIO
from ert.test import ExtendedTestCase, TestAreaContext
from ert.util import IntVector
ecl_lib = clib.ert_load("libecl")
ecl_wrapper = CWrapper(ecl_lib)
freadIndexedData = ecl_wrapper.prototype(
"void ecl_kw_fread_indexed_data(fortio, int, int, int, int_vector, char*)"
) # fortio, offset, type, count, index_map, buffer
eclFileIndexedRead = ecl_wrapper.prototype(
"void ecl_file_indexed_read(ecl_file, char*, int, int_vector, char*)"
) # ecl_file, kw, index, index_map, buffer
class EclIndexedReadTest(ExtendedTestCase):
def test_ecl_kw_indexed_read(self):
with TestAreaContext("ecl_kw_indexed_read") as area:
fortio = FortIO("index_test", mode=FortIO.WRITE_MODE)
element_count = 100000
ecl_kw = EclKW.create("TEST", element_count,
EclTypeEnum.ECL_INT_TYPE)
for index in range(element_count):
ecl_kw[index] = index
ecl_kw.fwrite(fortio)
