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 )")
cfunc.alloc_rectangular = cwrapper.prototype(
"c_void_p ecl_grid_alloc_rectangular( int , int , int , double , double , double , int*)"
)
cfunc.num_coarse_groups = cwrapper.prototype(
"int ecl_grid_get_num_coarse_groups( ecl_grid )")
# 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 )")
return cfunc.double_ptr(self)
else:
raise ValueError("Only numeric types can export data pointer")
#################################################################
# 2. Creating a wrapper object around the libecl library,
# registering the type map : ecl_kw <-> EclKW
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType("ecl_kw", EclKW)
# 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_kw")
cfunc.load_grdecl = cwrapper.prototype(
"c_void_p ecl_kw_fscanf_alloc_grdecl_dynamic__( FILE , char* , bool , int )"
)
cfunc.fseek_grdecl = cwrapper.prototype(
"bool ecl_kw_grdecl_fseek_kw(char* , bool , FILE )")
cfunc.fprintf_grdecl = cwrapper.prototype(
"void ecl_kw_fprintf_grdecl( ecl_kw , FILE )")
cfunc.fprintf_data = cwrapper.prototype(
"void ecl_kw_fprintf_data( ecl_kw , char* , FILE )")
cfunc.alloc_new = cwrapper.prototype(
"c_void_p ecl_kw_alloc( char* , int , ecl_type_enum )")
cfunc.copyc = cwrapper.prototype("c_void_p ecl_kw_alloc_copy( ecl_kw )")
cfunc.sub_copy = cwrapper.prototype(
QueueDriverEnum.RSH_DRIVER,
max_running,
options=options)
#Legacy enum support for ecl_local.py
LSF_DRIVER = QueueDriverEnum.LSF_DRIVER
RSH_DRIVER = QueueDriverEnum.RSH_DRIVER
LOCAL_DRIVER = QueueDriverEnum.LOCAL_DRIVER
#################################################################
cwrapper = CWrapper(JOB_QUEUE_LIB)
cwrapper.registerType("driver", Driver)
cwrapper.registerType("job", Job)
cfunc = CWrapperNameSpace("driver")
cfunc.alloc_driver_lsf = cwrapper.prototype(
"c_void_p queue_driver_alloc_LSF( char* , char* , char* )")
cfunc.alloc_driver_local = cwrapper.prototype(
"c_void_p queue_driver_alloc_local( )")
cfunc.alloc_driver_rsh = cwrapper.prototype(
"c_void_p queue_driver_alloc_RSH( char* , c_void_p )")
cfunc.alloc_driver = cwrapper.prototype(
"c_void_p queue_driver_alloc( int )")
cfunc.set_driver_option = cwrapper.prototype(
"void queue_driver_set_option(driver , char* , char*)")
cfunc.free_driver = cwrapper.prototype(
"void queue_driver_free( driver )")
cfunc.submit = cwrapper.prototype(
self.__ecl_file.close()
return False
def openEclFile(file_name, flags=0):
return EclFileContextManager(EclFile(file_name, flags))
# 2. Creating a wrapper object around the libecl library,
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType("ecl_file", EclFile)
# 3. Installing the c-functions used to manipulate ecl_file instances.
# These functions are used when implementing the EclFile class, not
# used outside this scope.
cfunc = CWrapperNameSpace("ecl_file")
cfunc.open = cwrapper.prototype("c_void_p ecl_file_open( char* , int )")
cfunc.writable = cwrapper.prototype(
"bool ecl_file_writable( ecl_file )")
cfunc.new = cwrapper.prototype("c_void_p ecl_file_alloc_empty( )")
cfunc.save_kw = cwrapper.prototype(
"void ecl_file_save_kw( ecl_file , ecl_kw )")
cfunc.select_block = cwrapper.prototype(
"bool ecl_file_select_block( ecl_file , char* , int )")
cfunc.restart_block_time = cwrapper.prototype(
"bool ecl_file_select_rstblock_sim_time( ecl_file , time_t )")
cfunc.restart_block_step = cwrapper.prototype(
"bool ecl_file_select_rstblock_report_step( ecl_file , int )")
cfunc.restart_block_iselect = cwrapper.prototype(
# 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 ert.util import UTIL_LIB
from ert.cwrap import CWrapper, CWrapperNameSpace
def quantile( data, q ):
return cfunc.quantile(data, q)
def quantile_sorted( data, q ):
return cfunc.quantile_sorted(data, q)
cwrapper = CWrapper(UTIL_LIB)
cfunc = CWrapperNameSpace("stat")
cfunc.quantile = cwrapper.prototype("double statistics_empirical_quantile( double_vector , double )")
cfunc.quantile_sorted = cwrapper.prototype("double statistics_empirical_quantile( double_vector , double )")
["CASE-10" , "CASE-9"]
>> l.sort( strcmp_int )
>> print l
["CASE-9" , "CASE-10"]
When the standard strcmp() function is used for comparing strings
the '1' will compare as less than the '9' and the order will be
the reverse. Observe that the '-' is not interpreted as a sign
prefix. The strcmp_int function will interpret '.' as separating
character, wheras the strcmp_float() function will interpret '.'
as a descimal point.
"""
return cfunc.strcmp_int(s1, s2)
def strcmp_float(s1, s2):
"""
Function to compare strings with embedded numbers.
See documentation of strcmp_int() for further details.
"""
return cfunc.strcmp_float(s1, s2)
cwrapper = CWrapper(UTIL_LIB)
cfunc = CWrapperNameSpace("util_func")
cfunc.strcmp_int = cwrapper.prototype("int util_strcmp_int( char* , char* )")
cfunc.strcmp_float = cwrapper.prototype(
"int util_strcmp_float( char* , char* )")
def set_name(self, name):
cfunc.set_name(self, name)
def get_name(self):
return cfunc.get_name(self)
name = property(get_name, set_name)
# 2. Creating a wrapper object around the libecl library.
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType("ecl_region", EclRegion)
# 3. Installing the c-functions used to manipulate.
cfunc = CWrapperNameSpace("ecl_region")
cfunc.alloc = cwrapper.prototype(
"c_void_p ecl_region_alloc( ecl_grid , bool )")
cfunc.free = cwrapper.prototype("void ecl_region_free( ecl_region )")
cfunc.reset = cwrapper.prototype("void ecl_region_reset( ecl_region )")
cfunc.select_all = cwrapper.prototype(
"void ecl_region_select_all( ecl_region )")
cfunc.deselect_all = cwrapper.prototype(
"void ecl_region_deselect_all( ecl_region )")
cfunc.select_equal = cwrapper.prototype(
"void ecl_region_select_equal( ecl_region , ecl_kw , int )")
cfunc.deselect_equal = cwrapper.prototype(
"void ecl_region_deselect_equal( ecl_region , ecl_kw , int)")
i.e. you must subtract 1 from the (i,j,k) values given in the ECLIPSE input.
"""
cell_ptr = cfunc_rft.lookup_ijk(self, ijk[0], ijk[1], ijk[2])
if cell_ptr:
return self.__cell_ref(cell_ptr)
else:
return None
# 2. Creating a wrapper object around the libecl library,
# registering the type map : ecl_kw <-> EclKW
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType("ecl_rft_file", EclRFTFile)
cwrapper.registerType("ecl_rft", EclRFT)
cfunc_file = CWrapperNameSpace("ecl_rft_file")
cfunc_rft = CWrapperNameSpace("ecl_rft")
cfunc_file.load = cwrapper.prototype(
"c_void_p ecl_rft_file_alloc_case( char* )")
cfunc_file.has_rft = cwrapper.prototype(
"bool ecl_rft_file_case_has_rft( char* )")
cfunc_file.free = cwrapper.prototype("void ecl_rft_file_free( ecl_rft_file )")
cfunc_file.get_size = cwrapper.prototype(
"int ecl_rft_file_get_size__( ecl_rft_file , char* , time_t)")
cfunc_file.iget = cwrapper.prototype(
"c_void_p ecl_rft_file_iget_node( ecl_rft_file , int )")
cfunc_file.get_num_wells = cwrapper.prototype(
"int ecl_rft_file_get_num_wells( ecl_rft_file )")
cfunc_file.get_rft = cwrapper.prototype(
"c_void_p ecl_rft_file_get_well_time_rft( ecl_rft_file , char* , time_t)")
# Oil / Water system
soil1 = 1 - swat1
soil2 = 1 - swat2
soil1.name = "SOIL"
soil2.name = "SOIL"
phase_list += [(soil1, soil2)]
else:
# Gas / Water system
sgas1 = 1 - swat1
sgas2 = 1 - swat2
sgas1.name = "SGAS"
sgas2.name = "SGAS"
phase_list += [(sgas1, sgas2)]
porv1 = restart_file1.iget_named_kw("RPORV", 0)
porv2 = restart_file2.iget_named_kw("RPORV", 0)
deltag = 0
for (sat1, sat2) in phase_list:
rho_name = "%s_DEN" % sat1.name[1:]
rho1 = restart_file1.iget_named_kw(rho_name, 0)
rho2 = restart_file2.iget_named_kw(rho_name, 0)
deltag += phase_deltag(xyz, grid, init_file, sat1, rho1, porv1, sat2, rho2, porv2)
return deltag
cwrapper = CWrapper(ECL_LIB)
cfunc = CWrapperNameSpace("ecl_grav")
cfunc.phase_deltag = cwrapper.prototype("double ecl_grav_phase_deltag( double, double ,double , c_void_p , c_void_p , c_void_p , c_void_p , c_void_p , c_void_p , c_void_p , c_void_p)")
class EclFileFlagEnum(BaseCEnum):
ECL_FILE_CLOSE_STREAM = None
ECL_FILE_WRITABLE = None
EclFileFlagEnum.addEnum("ECL_FILE_CLOSE_STREAM", 1)
EclFileFlagEnum.addEnum("ECL_FILE_WRITABLE", 2)
EclFileFlagEnum.registerEnum(ECL_LIB, "ecl_file_flag_enum")
#-----------------------------------------------------------------
cwrapper = CWrapper(ECL_LIB)
cfunc = CWrapperNameSpace("ecl_util")
cfunc.get_num_cpu = cwrapper.prototype("int ecl_util_get_num_cpu( char* )")
cfunc.get_file_type = cwrapper.prototype(
"ecl_file_enum ecl_util_get_file_type( char* , bool* , int*)")
cfunc.get_type_name = cwrapper.prototype("char* ecl_util_get_type_name( int )")
cfunc.get_start_date = cwrapper.prototype(
"time_t ecl_util_get_start_date( char* )")
class EclUtil(object):
@staticmethod
def get_num_cpu(datafile):
"""
Parse ECLIPSE datafile and determine how many CPUs are needed.
return cfunc.get_gas_flowrate( self )
@property
def water_flowrate(self):
return cfunc.get_water_flowrate( self )
#################################################################
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType( "rft_cell" , RFTCell)
cwrapper.registerType( "ecl_rft_cell" , EclRFTCell )
cwrapper.registerType( "ecl_plt_cell" , EclPLTCell )
cfunc = CWrapperNameSpace("ecl_rft_cell")
cfunc.alloc_RFT = cwrapper.prototype("c_void_p ecl_rft_cell_alloc_RFT( int, int , int , double , double , double , double)")
cfunc.alloc_PLT = cwrapper.prototype("c_void_p ecl_rft_cell_alloc_PLT( int, int , int , double , double , double, double , double, double , double , double , double , double , double )")
cfunc.free = cwrapper.prototype("void ecl_rft_cell_free( rft_cell )")
cfunc.get_pressure = cwrapper.prototype("double ecl_rft_cell_get_pressure( rft_cell )")
cfunc.get_depth = cwrapper.prototype("double ecl_rft_cell_get_depth( rft_cell )")
cfunc.get_i = cwrapper.prototype("int ecl_rft_cell_get_i( rft_cell )")
cfunc.get_j = cwrapper.prototype("int ecl_rft_cell_get_j( rft_cell )")
cfunc.get_k = cwrapper.prototype("int ecl_rft_cell_get_k( rft_cell )")
cfunc.get_swat = cwrapper.prototype("double ecl_rft_cell_get_swat( ecl_rft_cell )")
cfunc.get_soil = cwrapper.prototype("double ecl_rft_cell_get_soil( ecl_rft_cell )")
cfunc.get_sgas = cwrapper.prototype("double ecl_rft_cell_get_sgas( ecl_rft_cell )")
timeout = property(get_timeout, set_timeout)
#-----------------------------------------------------------------
def link_content(self, directory):
cfunc.link_directory_content(self, directory)
def link_path(self, path):
cfunc.link_path(self, path)
cwrapper = CWrapper(UTIL_LIB)
cwrapper.registerType("latex", LaTeX)
# 3. Installing the c-functions used to manipulate.
cfunc = CWrapperNameSpace("latex")
cfunc.alloc = cwrapper.prototype("c_void_p latex_alloc( char* , bool )")
cfunc.free = cwrapper.prototype("void latex_free( latex )")
cfunc.compile = cwrapper.prototype(
"bool latex_compile(latex , bool , bool , bool)")
cfunc.get_runpath = cwrapper.prototype("char* latex_get_runpath( latex )")
cfunc.get_target = cwrapper.prototype(
"char* latex_get_target_file( latex )")
cfunc.set_target = cwrapper.prototype(
"void latex_set_target_file( latex , char* )")
cfunc.set_timeout = cwrapper.prototype(
"void latex_set_timeout( latex , int )")
cfunc.get_timeout = cwrapper.prototype("int latex_get_timeout( latex )")
cfunc.compile_in_place = cwrapper.prototype(
"bool latex_compile_in_place( latex )")
cfunc.link_directory_content = cwrapper.prototype(
If supplied the optional argument @region should be an
EclRegion() instance; this region will be used to limit the
part of the reserviour included in the subsidence calculations.
The argument @compressibility is the total reservoir compressibility.
"""
return cfunc.eval(self, base_survey, monitor_survey, region, pos[0],
pos[1], pos[2], compressibility, poisson_ratio)
# 2. Creating a wrapper object around the libecl library,
cwrapper = CWrapper(ECL_LIB)
cwrapper.registerType("ecl_subsidence", EclSubsidence)
# 3. Installing the c-functions used to manipulate ecl_subsidence instances.
# These functions are used when implementing the EclSubsidence class, not
# used outside this scope.
cfunc = CWrapperNameSpace("ecl_subsidence")
cfunc.subsidence_alloc = cwrapper.prototype(
"c_void_p ecl_subsidence_alloc( ecl_grid , ecl_file )")
cfunc.free = cwrapper.prototype("void ecl_subsidence_free( ecl_subsidence )")
# Return value ignored in the add_survey_xxx() functions:
cfunc.add_survey_PRESSURE = cwrapper.prototype(
"c_void_p ecl_subsidence_add_survey_PRESSURE( ecl_subsidence , char* , ecl_file )"
)
cfunc.eval = cwrapper.prototype(
"double ecl_subsidence_eval( ecl_subsidence , char* , char* , ecl_region , double , double , double, double, double)"
)
