def exportVisibleCells(self, caseId, viewName, exportKeyword='FLUXNUM', visibleActiveCellsValue=1, hiddenActiveCellsValue=0, inactiveCellsValue=0): return self.__execute(exportVisibleCells=Cmd.ExportVisibleCellsRequest(caseId=caseId, viewName=viewName, exportKeyword=exportKeyword, visibleActiveCellsValue=visibleActiveCellsValue, hiddenActiveCellsValue=hiddenActiveCellsValue, inactiveCellsValue=inactiveCellsValue))
def export_property( self, time_step, property_name, eclipse_keyword=property, undefined_value=0.0, export_file=property, ): """Export an Eclipse property Arguments: time_step (int): time step index property_name (str): property to export eclipse_keyword (str): Keyword used in export header. Defaults: value of property undefined_value (double): Value to use for undefined values. Defaults to 0.0 export_file (str): File name for export. Defaults to the value of property parameter """ return self._execute_command(exportProperty=Cmd.ExportPropertyRequest( caseId=self.id, timeStep=time_step, property=property_name, eclipseKeyword=eclipse_keyword, undefinedValue=undefined_value, exportFile=export_file, ))
def set_export_folder(self, export_type, path, create_folder=False): """ Set the export folder used for all export functions **Parameters**:: Parameter | Description | Type ---------------- | -------------------------------------------- | ----- export_type | String specifying what to export | String path | Path to folder | String create_folder | Create folder if it doesn't exist? | Boolean **Enum export_type**:: Option | Description --------------- | ------------ "COMPLETIONS" | "SNAPSHOTS" | "PROPERTIES" | "STATISTICS" | """ return self.__execute_command( setExportFolder=Commands_pb2.SetExportFolderRequest( type=export_type, path=path, createFolder=create_folder))
def create_well_bore_stability_plot(self, well_path, time_step, parameters=None): """Create a new well bore stability plot Arguments: well_path(str): well path name time_step(int): time step Returns: :class:`rips.generated.generated_classes.WellBoreStabilityPlot` """ pb2_parameters = None if parameters is not None: assert isinstance(parameters, WbsParameters) pb2_parameters = parameters.pb2_object() plot_result = self._execute_command( createWellBoreStabilityPlot=Cmd.CreateWbsPlotRequest( caseId=self.id, wellPath=well_path, timeStep=time_step, wbsParameters=pb2_parameters, )) project = self.ancestor(rips.project.Project) plot = project.plot(view_id=plot_result.createWbsPlotResult.viewId) return plot
def export_visible_cells( self, export_keyword="FLUXNUM", visible_active_cells_value=1, hidden_active_cells_value=0, inactive_cells_value=0, ): """Export special properties for all visible cells. Arguments: export_keyword (string): The keyword to export. Choices: 'FLUXNUM' or 'MULTNUM'. Default: 'FLUXNUM' visible_active_cells_value (int): Value to export forvisible active cells. Default: 1 hidden_active_cells_value (int): Value to export for hidden active cells. Default: 0 inactive_cells_value (int): Value to export for inactive cells. Default: 0 """ case_id = self.case().id return self._execute_command( exportVisibleCells=Cmd.ExportVisibleCellsRequest( caseId=case_id, viewId=self.id, exportKeyword=export_keyword, visibleActiveCellsValue=visible_active_cells_value, hiddenActiveCellsValue=hidden_active_cells_value, inactiveCellsValue=inactive_cells_value, ))
def export_data_as_las( self, export_folder, file_prefix="", export_tvdrkb=False, capitalize_file_names=False, resample_interval=0.0, convert_to_standard_units=False, ): """Export LAS file(s) for the current plot Arguments: export_folder(str): The path to export to. By default will use the global export folder file_prefix (str): Exported file name prefix export_tvdrkb(bool): Export in TVD-RKB format capitalize_file_names(bool): Make all file names upper case resample_interval(double): if > 0.0 the files will be resampled Returns: A list of files exported """ res = self._execute_command( exportWellLogPlotData=Commands_pb2.ExportWellLogPlotDataRequest( exportFormat="LAS", viewId=self.id, exportFolder=export_folder, filePrefix=file_prefix, exportTvdRkb=export_tvdrkb, capitalizeFileNames=capitalize_file_names, resampleInterval=resample_interval, convertCurveUnits=convert_to_standard_units, )) return res.exportWellLogPlotDataResult.exportedFiles
def exportPropertyInViews(self, caseId, viewNames, undefinedValue): if isinstance(viewNames, str): viewNames = [viewNames] return self.__execute(exportPropertyInViews=Cmd.ExportPropertyInViewsRequest(caseId=caseId, viewNames=viewNames, undefinedValue=undefinedValue))
def export_data_as_ascii(self, export_folder, file_prefix="", capitalize_file_names=False): """Export LAS file(s) for the current plot Arguments: export_folder(str): The path to export to. By default will use the global export folder file_prefix (str): Exported file name prefix capitalize_file_names(bool): Make all file names upper case Returns: A list of files exported """ res = self._execute_command( exportWellLogPlotData=Commands_pb2.ExportWellLogPlotDataRequest( exportFormat="ASCII", viewId=self.id, exportFolder=export_folder, filePrefix=file_prefix, exportTvdRkb=False, capitalizeFileNames=capitalize_file_names, resampleInterval=0.0, )) return res.exportWellLogPlotDataResult.exportedFiles
def setStartDir(self, path): """Set current start directory Arguments: path (str): path to directory """ return self.__execute(setStartDir=Cmd.FilePathRequest(path=path))
def create_saturation_pressure_plots(self): """ Create saturation pressure plots for the current case """ case_ids = [self.id] return self._execute_command( createSaturationPressurePlots=Cmd.CreateSatPressPlotRequest( caseIds=case_ids))
def exportMultiCaseSnapshots(self, gridListFile): """Export snapshots for a set of cases Arguments: gridListFile (str): Path to a file containing a list of grids to export snapshot for """ return self.__execute(exportMultiCaseSnapshot=Cmd.ExportMultiCaseRequest(gridListFile=gridListFile))
def export_msw(self, well_path): """ Export Eclipse Multi-segment-well model to file Arguments: well_path(str): Well path name """ return self._execute_command( exportMsw=Cmd.ExportMswRequest(caseId=self.id, wellPath=well_path))
def create_view(self): """Create a new view in the current case Returns: :class:`rips.generated.generated_classes.View` """ return self.view( self._execute_command(createView=Cmd.CreateViewRequest( caseId=self.id)).createViewResult.viewId)
def openProject(self, path): """Open a project Arguments: path (str): path to project file """ return self.__execute(openProject=Cmd.FilePathRequest(path=path))
def export_multi_case_snapshots(self, grid_list_file): """Export snapshots for a set of cases Arguments: grid_list_file (str): Path to a file containing a list of grids to export snapshot for """ return self._execute_command( exportMultiCaseSnapshot=Commands_pb2.ExportMultiCaseRequest( gridListFile=grid_list_file))
def exportSimWellFractureCompletions(self, caseId, viewName, timeStep, simulationWellNames, fileSplit, compdatExport): if(isinstance(simulationWellNames, str)): simulationWellNames = [simulationWellNames] return self.__execute(exportSimWellFractureCompletions=Cmd.ExportSimWellPathFraqRequest(caseId=caseId, viewName=viewName, timeStep=timeStep, simulationWellNames=simulationWellNames, fileSplit=fileSplit, compdatExport=compdatExport))
def set_start_dir(self, path): """Set current start directory Arguments: path (str): path to directory """ return self.__execute_command(setStartDir=Commands_pb2.FilePathRequest( path=path))
def save(self, path=""): """Save the project to the existing project file, or to a new file Arguments: path(str): File path to the file to save the project to. If empty, saves to the active project file """ self._execute_command(saveProject=Commands_pb2.SaveProjectRequest( filePath=path)) return self
def open(self, path): """Open a new project from the given path Arguments: path(str): path to project file """ self._execute_command(openProject=Commands_pb2.FilePathRequest(path=path)) return self
def replaceSourceCases(self, gridListFile, caseGroupId=0): """Replace all source cases within a case group Arguments: gridListFile (str): path to file containing a list of cases caseGroupId (int): id of the case group to replace """ return self.__execute(replaceSourceCases=Cmd.ReplaceSourceCasesRequest(gridListFile=gridListFile, caseGroupId=caseGroupId))
def export_property(self, undefined_value=0.0): """Export the current Eclipse property from the view Arguments: undefined_value (double): Value to use for undefined values. Defaults to 0.0 """ case_id = self.case().id return self._execute_command( exportPropertyInViews=Cmd.ExportPropertyInViewsRequest( caseId=case_id, viewIds=[self.id], undefinedValue=undefined_value))
def createLgrForCompletions(self, caseId, timeStep, wellPathNames, refinementI, refinementJ, refinementK, splitType): if isinstance(wellPathNames, str): wellPathNames = [wellPathNames] return self.__execute(createLgrForCompletions=Cmd.CreateLgrForCompRequest(caseId=caseId, timeStep=timeStep, wellPathNames=wellPathNames, refinementI=refinementI, refinementJ=refinementJ, refinementK=refinementK, splitType=splitType))
def replace_source_cases(self, grid_list_file, case_group_id=0): """Replace all source grid cases within a case group Arguments: grid_list_file (str): path to file containing a list of cases case_group_id (int): id of the case group to replace """ return self._execute_command( replaceSourceCases=Commands_pb2.ReplaceSourceCasesRequest( gridListFile=grid_list_file, caseGroupId=case_group_id))
def create_statistics_case(self): """Create a Statistics case in the Grid Case Group Returns: :class:`rips.generated.resinsight_classes.EclipseCase` """ command_reply = self._execute_command( createStatisticsCase=Commands_pb2.CreateStatisticsCaseRequest( caseGroupId=self.group_id)) return Case(self.channel, command_reply.createStatisticsCaseResult.caseId)
def replaceCase(self, newGridFile, caseId=0): """Replace the given case with a new case loaded from file Arguments: newGridFile (str): path to EGRID file caseId (int): case Id to replace """ return self.__execute(replaceCase=Cmd.ReplaceCaseRequest(newGridFile=newGridFile, caseId=caseId))
def _execute_command(self, **command_params): self.__warnings = [] response, call = self._commands.Execute.with_call( Commands_pb2.CommandParams(**command_params)) for key, value in call.trailing_metadata(): value = value.replace(";;", "\n") if key == "warning": self.__warnings.append(value) return response
def set_fracture_containment(self, template_id, top_layer, base_layer): """Set fracture template containment parameters Arguments: template_id(int): ID of fracture template top_layer (int): Top layer containment base_layer (int): Base layer containment """ return self._execute_command( setFractureContainment=Commands_pb2.SetFracContainmentRequest( id=template_id, topLayer=top_layer, baseLayer=base_layer))
def load_case(self, path, grid_only=False): """Load a new grid case from the given file path Arguments: path(str): file path to case Returns: :class:`rips.generated.generated_classes.Case` """ command_reply = self._execute_command( loadCase=Commands_pb2.FilePathRequest(path=path, gridOnly=grid_only)) return self.case(command_reply.loadCaseResult.id)
def createGridCaseGroup(self, casePaths): """Create a Grid Case Group from a list of cases Arguments: casePaths (list): list of file path strings Returns: A case group id and name """ commandReply = self.__execute(createGridCaseGroup=Cmd.CreateGridCaseGroupRequest(casePaths=casePaths)) return (commandReply.createGridCaseGroupResult.groupId, commandReply.createGridCaseGroupResult.groupName)
def replace(self, new_grid_file): """Replace the current case grid with a new grid loaded from file Arguments: new_egrid_file (str): Path to EGRID file """ project = self.ancestor(rips.project.Project) self._execute_command(replaceCase=Cmd.ReplaceCaseRequest( newGridFile=new_grid_file, caseId=self.id)) new_case = project.case(self.id) self.copy_from(new_case)