""" return self.test_case.cmpSummaryVector(self.ref_case, key, sample=sample) def test_keys(self): """ Will return a list of summary keys in the test case. """ return self.test_case.keys() def test_wells(self): """ Will return a list of wells keys in the test case. """ return self.test_case.wells() monkey_the_camel(EclCase, 'loadSummary', EclCase.load_summary) monkey_the_camel(EclCase, 'startTimeEqual', EclCase.start_time_equal) monkey_the_camel(EclCase, 'endTimeEqual', EclCase.end_time_equal) monkey_the_camel(EclCase, 'cmpSummaryVector', EclCase.cmp_summary_vector) monkey_the_camel(EclCmp, 'initCheck', EclCmp.init_check) monkey_the_camel(EclCmp, 'hasSummaryVector', EclCmp.has_summary_vector) monkey_the_camel(EclCmp, 'endTimeEqual', EclCmp.end_time_equal) monkey_the_camel(EclCmp, 'cmpSummaryVector', EclCmp.cmp_summary_vector) monkey_the_camel(EclCmp, 'testKeys', EclCmp.test_keys) monkey_the_camel(EclCmp, 'testWells', EclCmp.test_wells)
layer.addInterpBarrier(c0, c1) print('%g,%g -> %d,%d %d' % (p1[0], p1[1], i,j,c1)) print('Adding barrier %d -> %d' % (c0, c1)) c0 = c1 def get_geo_layer(self): """Returns the underlying geometric layer.""" return self._get_layer() def cell_contact(self, p1, p2): layer = self.getGeoLayer() return layer.cellContact(p1,p2) monkey_the_camel(FaultBlockLayer, 'scanKeyword', FaultBlockLayer.scan_keyword) monkey_the_camel(FaultBlockLayer, 'loadKeyword', FaultBlockLayer.load_keyword) monkey_the_camel(FaultBlockLayer, 'getBlock', FaultBlockLayer.get_block) monkey_the_camel(FaultBlockLayer, 'deleteBlock', FaultBlockLayer.delete_block) monkey_the_camel(FaultBlockLayer, 'addBlock', FaultBlockLayer.add_block) monkey_the_camel(FaultBlockLayer, 'getNextID', FaultBlockLayer.get_next_id) monkey_the_camel(FaultBlockLayer, 'getK', FaultBlockLayer.get_k) monkey_the_camel(FaultBlockLayer, 'scanLayer', FaultBlockLayer.scan_layer) monkey_the_camel(FaultBlockLayer, 'insertBlockContent', FaultBlockLayer.insert_block_content) monkey_the_camel(FaultBlockLayer, 'exportKeyword', FaultBlockLayer.export_keyword) monkey_the_camel(FaultBlockLayer, 'addFaultBarrier', FaultBlockLayer.add_fault_barrier) monkey_the_camel(FaultBlockLayer, 'addFaultLink', FaultBlockLayer.add_fault_link) monkey_the_camel(FaultBlockLayer, 'joinFaults', FaultBlockLayer.join_faults) monkey_the_camel(FaultBlockLayer, 'addPolylineBarrier', FaultBlockLayer.add_polyline_barrier) monkey_the_camel(FaultBlockLayer, 'getGeoLayer', FaultBlockLayer.get_geo_layer) monkey_the_camel(FaultBlockLayer, 'cellContact', FaultBlockLayer.cell_contact)
""" self._fwrite(fortio, 0) class EclFileContextManager(object): def __init__(self, ecl_file): self.__ecl_file = ecl_file def __enter__(self): return self.__ecl_file def __exit__(self, exc_type, exc_val, exc_tb): self.__ecl_file.close() return False def openEclFile(file_name, flags=0): print('The function openEclFile is deprecated, use open_ecl_file.') return open_ecl_file(file_name, flags) def open_ecl_file(file_name, flags=0): return EclFileContextManager(EclFile(file_name, flags)) monkey_the_camel(EclFile, 'getFileType', EclFile.get_filetype, staticmethod) monkey_the_camel(EclFile, 'blockView', EclFile.block_view) monkey_the_camel(EclFile, 'blockView2', EclFile.block_view2) monkey_the_camel(EclFile, 'restartView', EclFile.restart_view) monkey_the_camel(EclFile, 'getFilename', EclFile.get_filename)
def is_total(self): """ Will check if the node corresponds to a total quantity. The question of whether a variable corresponds to a 'total' quantity or not can be interesting for e.g. interpolation purposes. The actual question whether a quantity is total or not is based on a hardcoded list in smspec_node_set_flags() in smspec_node.c; this list again is based on the tables 2.7 - 2.11 in the ECLIPSE fileformat documentation. """ return self._node_is_total() def is_historical(self): """ Checks if the key corresponds to a historical variable. The check is only based on the last character; all variables ending with 'H' are considered historical. """ return self._node_is_historical() monkey_the_camel(EclSMSPECNode, 'getKey1', EclSMSPECNode.get_key1) monkey_the_camel(EclSMSPECNode, 'getKey2', EclSMSPECNode.get_key2) monkey_the_camel(EclSMSPECNode, 'varType', EclSMSPECNode.var_type) monkey_the_camel(EclSMSPECNode, 'getNum', EclSMSPECNode.get_num) monkey_the_camel(EclSMSPECNode, 'isRate', EclSMSPECNode.is_rate) monkey_the_camel(EclSMSPECNode, 'isTotal', EclSMSPECNode.is_total) monkey_the_camel(EclSMSPECNode, 'isHistorical', EclSMSPECNode.is_historical)
def openFortIO(file_name, mode=FortIO.READ_MODE, fmt_file=False, endian_flip_header=True): """Will create FortIO based context manager for use with with. The with: statement and context managers is a good alternative in the situation where you need to ensure resource cleanup. import sys from ecl.ecl import FortIO, EclFile rst_file = EclFile(sys.argv[1]) with openFortIO("PRESSURE", mode=FortIO.WRITE_MODE) as fortio: for kw in rst_file: if kw.name() == "PRESSURE": kw.write(fortio) """ return FortIOContextManager( FortIO(file_name, mode=mode, fmt_file=fmt_file, endian_flip_header=endian_flip_header)) monkey_the_camel(FortIO, 'getPosition', FortIO.get_position) monkey_the_camel(FortIO, 'isFortranFile', FortIO.is_fortran_file, classmethod)
if index >= len(self): raise IndexError("Out of range") return self._iget_key(index) def __len__(self): return self._get_size() def free(self): self._free() def add_keyword(self, keyword): success = self._add(keyword) if not success: raise KeyError("Failed to add keyword to vector") def add_keywords(self, keyword_pattern): self._add_multiple(keyword_pattern) def __repr__(self): return self._create_repr('len=%d' % len(self)) def copy(self, ecl_sum): return self._alloc_copy(ecl_sum) monkey_the_camel(EclSumKeyWordVector, 'addKeyword', EclSumKeyWordVector.add_keyword) monkey_the_camel(EclSumKeyWordVector, 'addKeywords', EclSumKeyWordVector.add_keywords)
""" i_list = IntVector() j_list = IntVector() self._cells_equal(value, i_list, j_list) ij_list= [] for (i,j) in zip(i_list, j_list): ij_list.append((i,j)) return ij_list def count_equal(self, value): return self._count_equal(value) monkey_the_camel(Layer, 'activeCell', Layer.active_cell) monkey_the_camel(Layer, 'updateActive', Layer.update_active) monkey_the_camel(Layer, 'bottomBarrier', Layer.bottom_barrier) monkey_the_camel(Layer, 'leftBarrier', Layer.left_barrier) monkey_the_camel(Layer, 'getNX', Layer.get_nx) monkey_the_camel(Layer, 'getNY', Layer.get_ny) monkey_the_camel(Layer, 'cellContact', Layer.cell_contact) monkey_the_camel(Layer, 'addInterpBarrier', Layer.add_interp_barrier) monkey_the_camel(Layer, 'addPolylineBarrier', Layer.add_polyline_barrier) monkey_the_camel(Layer, 'addFaultBarrier', Layer.add_fault_barrier) monkey_the_camel(Layer, 'addIJBarrier', Layer.add_ij_barrier) monkey_the_camel(Layer, 'cellSum', Layer.cell_sum) monkey_the_camel(Layer, 'clearCells', Layer.clear_cells) monkey_the_camel(Layer, 'updateConnected', Layer.update_connected) monkey_the_camel(Layer, 'cellsEqual', Layer.cells_equal) monkey_the_camel(Layer, 'countEqual', Layer.count_equal)
raise IndexError("Offset:%d invalid - size:%d" % (offset, len(self))) if self.getEclType() != other.getEclType(): raise TypeError("The two keywords have different type") if abs_epsilon is None: abs_epsilon = epsilon if rel_epsilon is None: rel_epsilon = epsilon return self._first_different(other, offset, abs_epsilon, rel_epsilon) monkey_the_camel(EclKW, 'intKeywords', EclKW.int_keywords, classmethod) monkey_the_camel(EclKW, 'isNumeric', EclKW.is_numeric) monkey_the_camel(EclKW, 'fortIOSize', EclKW.fort_io_size) monkey_the_camel(EclKW, 'setName', EclKW.set_name) monkey_the_camel(EclKW, 'getName', EclKW.get_name) monkey_the_camel(EclKW, 'getMinMax', EclKW.get_min_max) monkey_the_camel(EclKW, 'getMax', EclKW.get_max) monkey_the_camel(EclKW, 'getMin', EclKW.get_min) monkey_the_camel(EclKW, 'typeName', EclKW.type_name) monkey_the_camel(EclKW, 'getEclType', EclKW.get_ecl_type) monkey_the_camel(EclKW, 'numpyView', EclKW.numpy_view) monkey_the_camel(EclKW, 'numpyCopy', EclKW.numpy_copy) monkey_the_camel(EclKW, 'fixUninitialized', EclKW.fix_uninitialized) monkey_the_camel(EclKW, 'getDataPtr', EclKW.get_data_ptr) monkey_the_camel(EclKW, 'firstDifferent', EclKW.first_different)
def export_coord(self): return self._export_coord() def export_zcorn(self): return self._export_zcorn() def export_actnum(self): return self._export_actnum() def export_mapaxes(self): if not self._use_mapaxes(): return None return self._export_mapaxes() monkey_the_camel(EclGrid, 'loadFromGrdecl', EclGrid.load_from_grdecl, classmethod) monkey_the_camel(EclGrid, 'loadFromFile', EclGrid.load_from_file, classmethod) monkey_the_camel(EclGrid, 'createRectangular', EclGrid.create_rectangular, classmethod) monkey_the_camel(EclGrid, 'dualGrid', EclGrid.dual_grid) monkey_the_camel(EclGrid, 'getDims', EclGrid.get_dims) monkey_the_camel(EclGrid, 'getNX', EclGrid.get_nx) monkey_the_camel(EclGrid, 'getNY', EclGrid.get_ny) monkey_the_camel(EclGrid, 'getNZ', EclGrid.get_nz) monkey_the_camel(EclGrid, 'getGlobalSize', EclGrid.get_global_size) monkey_the_camel(EclGrid, 'getNumActive', EclGrid.get_num_active) monkey_the_camel(EclGrid, 'getNumActiveFracture', EclGrid.get_num_active_fracture) monkey_the_camel(EclGrid, 'getBoundingBox2D', EclGrid.get_bounding_box_2d) monkey_the_camel(EclGrid, 'getName', EclGrid.get_name) monkey_the_camel(EclGrid, 'validCellGeometry', EclGrid.valid_cell_geometry) monkey_the_camel(EclGrid, 'getNodePos', EclGrid.get_node_pos) monkey_the_camel(EclGrid, 'getCellCorner', EclGrid.get_cell_corner)
count += 1 except ValueError: pass if count == 1: xy_list = [] for ij in join: xyz = fault1.__grid.getNodeXYZ(ij[0], ij[1], k) xy_list.append((xyz[0], xyz[1])) return xy_list else: return fault1.endJoin(fault2, k) monkey_the_camel(FaultLayer, 'addSegment', FaultLayer.add_segment) monkey_the_camel(FaultLayer, 'getK', FaultLayer.get_k) monkey_the_camel(FaultLayer, 'getNeighborCells', FaultLayer.get_neighbor_cells) monkey_the_camel(FaultLayer, 'getPolyline', FaultLayer.get_polyline) monkey_the_camel(FaultLayer, 'getIJPolyline', FaultLayer.get_ij_polyline) monkey_the_camel(FaultLayer, 'numLines', FaultLayer.num_lines) monkey_the_camel(FaultLayer, 'processSegments', FaultLayer.process_segments) monkey_the_camel(Fault, 'hasLayer', Fault.has_layer) monkey_the_camel(Fault, 'addLayer', Fault.add_layer) monkey_the_camel(Fault, 'createSegment', Fault.create_segment) monkey_the_camel(Fault, 'addRecord', Fault.add_record) monkey_the_camel(Fault, 'getName', Fault.get_name) monkey_the_camel(Fault, 'getNeighborCells', Fault.get_neighbor_cells) monkey_the_camel(Fault, 'getPolyline', Fault.get_polyline) monkey_the_camel(Fault, 'getIJPolyline', Fault.get_ij_polyline)
integer for the step number. """ fmt_file = ctypes.c_bool() report_step = ctypes.c_int(-1) file_type = EclUtil._get_file_type(filename, ctypes.byref(fmt_file), ctypes.byref(report_step)) if report_step.value == -1: step = None else: step = report_step.value return (file_type, fmt_file.value, step) @staticmethod def report_step(filename): report_step = EclUtil._get_report_step(filename) if report_step < 0: raise ValueError("Could not infer report step from: %s" % filename) return report_step get_num_cpu = EclUtil.get_num_cpu get_file_type = EclUtil.get_file_type get_start_date = EclUtil.get_start_date monkey_the_camel(EclUtil, 'inspectExtension', EclUtil.inspect_extension, staticmethod) monkey_the_camel(EclUtil, 'reportStep', EclUtil.report_step, staticmethod)
The monitor survey can be 'None' - the resulting answer has nothing whatsovever to do with subsidence, but can be interesting to determine the numerical size of the quantities which are subtracted in a 4D study. The @pos argument should be a tuple of three elements with the (utm_x , utm_y , depth) position where we want to evaluate the change in subsidence. 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. """ if not base_survey in self: raise KeyError("No such survey: %s" % base_survey) if not monitor_survey in self: raise KeyError("No such survey: %s" % monitor_survey) return self._eval(base_survey, monitor_survey, region, pos[0], pos[1], pos[2], compressibility, poisson_ratio) def free(self): self._free() monkey_the_camel(EclSubsidence, 'evalGeertsma', EclSubsidence.eval_geertsma)
contact with this block. """ neighbour_id_list = IntVector() if polylines is None: polylines = CPolylineCollection() self._get_neighbours(connected_only, polylines, neighbour_id_list) parent_layer = self.getParentLayer() neighbour_list = [] for id in neighbour_id_list: neighbour_list.append(parent_layer.getBlock(id)) return neighbour_list def get_parent_layer(self): return self.parent() monkey_the_camel(FaultBlock, 'getCentroid', FaultBlock.get_centroid) monkey_the_camel(FaultBlock, 'countInside', FaultBlock.count_inside) monkey_the_camel(FaultBlock, 'getBlockID', FaultBlock.get_block_id) monkey_the_camel(FaultBlock, 'assignToRegion', FaultBlock.assign_to_region) monkey_the_camel(FaultBlock, 'getRegionList', FaultBlock.get_region_list) monkey_the_camel(FaultBlock, 'addCell', FaultBlock.add_cell) monkey_the_camel(FaultBlock, 'getGlobalIndexList', FaultBlock.get_global_index_list) monkey_the_camel(FaultBlock, 'getEdgePolygon', FaultBlock.get_edge_polygon) monkey_the_camel(FaultBlock, 'containsPolyline', FaultBlock.contains_polyline) monkey_the_camel(FaultBlock, 'getNeighbours', FaultBlock.get_neighbours) monkey_the_camel(FaultBlock, 'getParentLayer', FaultBlock.get_parent_layer)
else: var_list = StringList() for key in keys: var_list |= self.keys(pattern=key) self._export_csv(filename, var_list, date_format, sep) import ecl.ecl.ecl_sum_keyword_vector EclSum._dump_csv_line = EclPrototype( "void ecl_sum_fwrite_interp_csv_line(ecl_sum, time_t, ecl_sum_vector, FILE)", bind=False) EclSum._get_interp_vector = EclPrototype( "void ecl_sum_get_interp_vector(ecl_sum, time_t, ecl_sum_vector, double_vector)", bind=False) monkey_the_camel(EclSum, 'varType', EclSum.var_type, classmethod) monkey_the_camel(EclSum, 'addVariable', EclSum.add_variable) monkey_the_camel(EclSum, 'addTStep', EclSum.add_t_step) monkey_the_camel(EclSum, 'assertKeyValid', EclSum.assert_key_valid) monkey_the_camel(EclSum, 'scaleVector', EclSum.scale_vector) monkey_the_camel(EclSum, 'shiftVector', EclSum.shift_vector) monkey_the_camel(EclSum, 'timeRange', EclSum.time_range) monkey_the_camel(EclSum, 'blockedProduction', EclSum.blocked_production) monkey_the_camel(EclSum, 'getDataStartTime', EclSum.get_data_start_time) monkey_the_camel(EclSum, 'getStartTime', EclSum.get_start_time) monkey_the_camel(EclSum, 'getEndTime', EclSum.get_end_time) monkey_the_camel(EclSum, 'solveDates', EclSum.solve_dates) monkey_the_camel(EclSum, 'solveDays', EclSum.solve_days) monkey_the_camel(EclSum, 'dumpCSVLine', EclSum.dump_csv_line) monkey_the_camel(EclSum, 'exportCSV', EclSum.export_csv)
""" @rtype: FaultBlockLayer """ if isinstance(index, int): if 0 <= index < len(self): return self._get_layer(index).setParent(self) else: raise IndexError("Index:%d out of range [0,%d)" % (index, len(self))) else: raise TypeError("Index should be integer type") def get_layer(self, k): """ @rtype: FaultBlockLayer """ return self[k] def free(self): self._free() def scan_keyword(self, fault_block_kw): ok = self._scan_keyword(fault_block_kw) if not ok: raise ValueError("The fault block keyword had wrong type/size") monkey_the_camel(FaultBlockCollection, 'getLayer', FaultBlockCollection.get_layer) monkey_the_camel(FaultBlockCollection, 'scanKeyword', FaultBlockCollection.scan_keyword)
used before you use the add_survey_FIP() method to add a survey based on the FIP keyword. """ self._new_std_density(phase_enum, default_density) def add_std_density(self, phase_enum, pvtnum, density): """ Add standard conditions density for PVT region @pvtnum. The new_std_density() method will add a standard conditions density which applies to all cells in the model. Using the add_std_density() method it is possible to add standard conditions densities on a per PVT region basis. You can add densities for as many PVT regions as you like, and then fall back to the default density for the others. The new_std_density() method must be called before calling the add_std_density() method. The new_std_density() and add_std_density() methods must be used before you use the add_survey_FIP() method to add a survey based on the FIP keyword. """ self._add_std_density(phase_enum, pvtnum, density) def free(self): self._free() monkey_the_camel(EclGrav, 'addSurvey', EclGrav.add_survey)
def load_faults(self, grid, fileH): for line in fileH: line = comment_regexp.sub("", line) line = line.strip() if line == "/": break if line: (name, I1, I2, J1, J2, K1, K2, face) = self.splitLine(line) if not self.hasFault(name): fault = Fault(grid, name) self.addFault(fault) else: fault = self.getFault(name) fault.addRecord(I1, I2, J1, J2, K1, K2, face) def load(self, grid, file_name): with open(file_name) as fileH: for line in fileH: if line.startswith("FAULTS"): self.loadFaults(grid, fileH) monkey_the_camel(FaultCollection, 'getGrid', FaultCollection.get_grid) monkey_the_camel(FaultCollection, 'getFault', FaultCollection.get_fault) monkey_the_camel(FaultCollection, 'hasFault', FaultCollection.has_fault) monkey_the_camel(FaultCollection, 'addFault', FaultCollection.add_fault) monkey_the_camel(FaultCollection, 'splitLine', FaultCollection.split_line) monkey_the_camel(FaultCollection, 'loadFaults', FaultCollection.load_faults)
return start_segment def pop_next(self, segment): (C1, C2) = segment.getCorners() if self.__count_map[C1] >= 1: next_segment = self.__segment_map[C1].values()[0] elif self.__count_map[C2] >= 1: next_segment = self.__segment_map[C2].values()[0] else: next_segment = None if next_segment: self.delSegment(next_segment) return next_segment def print_content(self): for d in self.__segment_map.values(): for (C, S) in d.iteritems(): print(S) monkey_the_camel(FaultSegment, 'getCorners', FaultSegment.get_corners) monkey_the_camel(FaultSegment, 'getC1', FaultSegment.get_c1) monkey_the_camel(FaultSegment, 'getC2', FaultSegment.get_c2) monkey_the_camel(SegmentMap, 'addSegment', SegmentMap.add_segment) monkey_the_camel(SegmentMap, 'delSegment', SegmentMap.del_segment) monkey_the_camel(SegmentMap, 'popStart', SegmentMap.pop_start) monkey_the_camel(SegmentMap, 'popNext', SegmentMap.pop_next) monkey_the_camel(SegmentMap, 'printContent', SegmentMap.print_content)
self.code = "trange = self.baseCase.timeRange(self.start, self.end, self.interval)\n" for (key, var) in self.keyList.items(): self.code += "%s = self.baseCase.blockedProduction(\"%s\", trange)\n" % ( var, key) self.code += "npv = 0\n" self.code += """ for i in range(len(trange) - 1): npv += %s varDict[\"npv\"] = npv """ % parsedExpression def eval_npv(self): byteCode = compile(self.code, "<string>", 'exec') varDict = {} eval(byteCode) return varDict["npv"] monkey_the_camel(NPVPriceVector, 'addItem', NPVPriceVector.add_item) monkey_the_camel(NPVPriceVector, 'assertDate', NPVPriceVector.assert_date, staticmethod) monkey_the_camel(NPVPriceVector, 'evalDate', NPVPriceVector.eval_date) monkey_the_camel(EclNPV, 'getExpression', EclNPV.get_expression) monkey_the_camel(EclNPV, 'setExpression', EclNPV.set_expression) monkey_the_camel(EclNPV, 'getKeyList', EclNPV.get_key_list) monkey_the_camel(EclNPV, 'addKey', EclNPV.add_key) monkey_the_camel(EclNPV, 'parseExpression', EclNPV.parse_expression) monkey_the_camel(EclNPV, 'evalNPV', EclNPV.eval_npv)
""" return self[index] def get(self , well_name , date ): """ Will look up the RFT object corresponding to @well and @date. Raise Exception if not found. """ if self.size( well = well_name , date = date) == 0: raise KeyError("No RFT for well:%s at %s" % (well_name , date)) rft = self._get_rft( well_name , CTime( date )) rft.setParent( self ) return rft def free(self): self._free( ) def __repr__(self): w = len(self) return self._create_repr('wells = %d' % w) monkey_the_camel(EclRFT, 'getWellName', EclRFT.get_well_name) monkey_the_camel(EclRFT, 'getDate', EclRFT.get_date) monkey_the_camel(EclRFTFile, 'getNumWells', EclRFTFile.get_num_wells) monkey_the_camel(EclRFTFile, 'getHeaders', EclRFTFile.get_headers)
(20, datetime.datetime( 2010 , 5 , 1 , 0 , 0 , 0 ) , 220.0) ] For a non-unified restart file the list will have only one element. """ self.assertHeaders() time_list = [] for header in self.rst_headers: time_list.append((header.getReportStep(), header.getSimDate(), header.getSimDays())) return time_list def headers(self): self.assertHeaders() return self.rst_headers def get_header(self, index): self.assertHeaders() return self.rst_headers[index] monkey_the_camel(EclRestartHead, 'getReportStep', EclRestartHead.get_report_step) monkey_the_camel(EclRestartHead, 'getSimDate', EclRestartHead.get_sim_date) monkey_the_camel(EclRestartHead, 'getSimDays', EclRestartHead.get_sim_days) monkey_the_camel(EclRestartFile, 'assertHeaders', EclRestartFile.assert_headers) monkey_the_camel(EclRestartFile, 'timeList', EclRestartFile.time_list)
if len(bound) != 2: raise ValueError( "Expected bound to consist of two elements, was %s", str(bound)) if not (isinstance(bound[0], int) and isinstance(bound[1], int)): raise TypeError( "Expected bound to consist of two integers, ", "was %s (%s)" % (str(bound), str((map(type, bound))))) if not (0 <= bound[0] <= bound[1] < n): raise ValueError( "Expected bounds to have the following format: " + "0 <= lower bound <= upper_bound < ni, " + "was %d <=? %d <=? %d <? %d." % (0, bound[0], bound[1], n)) return ijk_bounds @classmethod def assert_decomposition_change(cls, ijk_bounds, decomposition_change): if sum(zip(*ijk_bounds)[0]) % 2 == 1 and not decomposition_change: raise ValueError( "The subgrid defined by %s " % str(ijk_bounds) + "will cause an unintended decomposition change. " + "Either change one of the lower bounds by 1 " + "or activate decomposition_change.") monkey_the_camel(EclGridGenerator, 'createRectangular', EclGridGenerator.create_rectangular, classmethod)
return self._get_ministep() def get_sim_time(self): """ @rtype: CTime """ return self._get_sim_time() def __getitem__(self, key): """ @rtype: double """ if not key in self: raise KeyError("Key '%s' is not available." % key) return self._get_from_key(key) def __setitem__(self, key, value): if not key in self: raise KeyError("Key '%s' is not available." % key) self._set_from_key(key, value) def __contains__(self, key): return self._has_key(key) def free(self): self._free(self) monkey_the_camel(EclSumTStep, 'getSimDays', EclSumTStep.get_sim_days) monkey_the_camel(EclSumTStep, 'getReport', EclSumTStep.get_report) monkey_the_camel(EclSumTStep, 'getMiniStep', EclSumTStep.get_mini_step) monkey_the_camel(EclSumTStep, 'getSimTime', EclSumTStep.get_sim_time)
def contains_active(self, active_index): """ Will check if the cell given by @active_index is part of the region. """ return self._contains_active(active_index) def kw_index_list(self, ecl_kw, force_active): c_ptr = self._get_kw_index_list(ecl_kw, force_active) index_list = IntVector.createCReference(c_ptr, self) return index_list @property def name(self): return self._get_name() def get_name(self): return self._get_name() def set_name(self, name): self._set_name(name) monkey_the_camel(EclRegion, 'selectTrue', EclRegion.select_true) monkey_the_camel(EclRegion, 'selectFalse', EclRegion.select_false) monkey_the_camel(EclRegion, 'selectFromLayer', EclRegion.select_from_layer) monkey_the_camel(EclRegion, 'getActiveList', EclRegion.get_active_list) monkey_the_camel(EclRegion, 'getGlobalList', EclRegion.get_global_list) monkey_the_camel(EclRegion, 'getIJKList', EclRegion.get_ijk_list) monkey_the_camel(EclRegion, 'getName', EclRegion.get_name) monkey_the_camel(EclRegion, 'setName', EclRegion.set_name)
rseg = FaultSegment(C2, C1) self.tryAppend(rseg) def start_point(self): pl = self.getPolyline() return pl[0] def end_point(self): pl = self.getPolyline() return pl[-1] def dump(self): print('-----------------------------------------------------------------') for segment in self: C1 = segment.getC1() C2 = segment.getC2() (J1, I1) = divmod(C1, self.__grid.getNX() + 1) (J2, I2) = divmod(C2, self.__grid.getNX() + 1) print('[Corner:%5d IJ:(%3d,%d)] -> [Corner:%5d IJ:(%3d,%d)]' % (C1, I1, J1, C2, I2, J2)) monkey_the_camel(FaultLine, 'tryAppend', FaultLine.try_append) monkey_the_camel(FaultLine, 'getK', FaultLine.get_k) monkey_the_camel(FaultLine, 'getPolyline', FaultLine.get_polyline) monkey_the_camel(FaultLine, 'getIJPolyline', FaultLine.get_ij_polyline) monkey_the_camel(FaultLine, 'getNeighborCells', FaultLine.get_neighbor_cells) monkey_the_camel(FaultLine, 'startPoint', FaultLine.start_point) monkey_the_camel(FaultLine, 'endPoint', FaultLine.end_point)
seqnum_index=None, report_step=None, sim_time=None, sim_days=None): if report_step is None: report_step = -1 if sim_time is None: sim_time = -1 if sim_days is None: sim_days = -1 if seqnum_index is None: seqnum_index = -1 view = self._restart_view(seqnum_index, report_step, CTime(sim_time), sim_days) if view is None: raise ValueError("No such restart block could be identiefied") view.setParent(parent=self) return view monkey_the_camel(EclFileView, 'numKeywords', EclFileView.num_keywords) monkey_the_camel(EclFileView, 'uniqueSize', EclFileView.unique_size) monkey_the_camel(EclFileView, 'blockView2', EclFileView.block_view2) monkey_the_camel(EclFileView, 'blockView', EclFileView.block_view) monkey_the_camel(EclFileView, 'restartView', EclFileView.restart_view)
def global_copy(self): """Will return a EclKW copy with nx*ny*nz elements. The returned copy will be of type EclKW; i.e. no default interpolation and only linear access in the [] operator. The main purpose of this is to facilitate iteration over the global index, and for writing binary files. """ return self.grid.globalKWCopy( self , self.getDefault() ) def dims(self): return (self.grid.getNX() , self.grid.getNY() , self.grid.getNZ()) def set_default(self, default_value): self.default_value = default_value def get_default(self): return self.default_value monkey_the_camel(Ecl3DKW, 'castFromKW', Ecl3DKW.cast_from_kw, classmethod) monkey_the_camel(Ecl3DKW, 'compressedCopy', Ecl3DKW.compressed_copy) monkey_the_camel(Ecl3DKW, 'globalCopy', Ecl3DKW.global_copy) monkey_the_camel(Ecl3DKW, 'setDefault', Ecl3DKW.set_default) monkey_the_camel(Ecl3DKW, 'getDefault', Ecl3DKW.get_default)