OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity

#4549 Add python method to get selected cells.

Browse Source 
Equivalent to GetSelectedCells in Octave.
This commit is contained in:
Kristian Bendiksen 2020-02-19 15:20:34 +01:00
parent c64281c525
commit 8a1fa38435
6 changed files with 248 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ApplicationCode/GrpcInterface/GrpcProtos/Case.proto
View File

@ -14,6 +14,7 @@ service Case
rpc GetCellCornersForActiveCells(CellInfoRequest) returns (stream CellCornersArray) {}
rpc GetCoarseningInfoArray(CaseRequest) returns (CoarseningInfoArray) {}
rpc GetTimeSteps(CaseRequest) returns (TimeStepDates) {}
rpc GetSelectedCells(CaseRequest) returns (stream SelectedCells) {}
rpc GetDaysSinceStart(CaseRequest) returns (DaysSinceStart) {}
rpc GetCaseInfo(CaseRequest) returns (CaseInfo) {}
rpc GetPdmObject(CaseRequest) returns (PdmObject) {}
@ -125,3 +126,15 @@ message DaysSinceStart
{
repeated double day_decimals = 1;
}
message SelectedCell
{
int32 grid_index = 1;
Vec3i ijk = 2;
}
message SelectedCells
{
repeated SelectedCell cells = 1;
}

43
ApplicationCode/GrpcInterface/Python/rips/PythonExamples/selected_cells.py Normal file
View File

@ -0,0 +1,43 @@
############################################################################
# This example prints center and corners for the currently selected cells
# in ResInsight
############################################################################
import rips
resinsight = rips.Instance.find()
if resinsight is not None:
cases = resinsight.project.cases()
print ("Got " + str(len(cases)) + " cases: ")
for case in cases:
print(case.name)
cells = case.selected_cells()
print("Found " + str(len(cells)) + " selected cells")
for cell in cells:
print("Selected cell: [{}, {}, {}] grid: {}".format(cell.ijk.i+1, cell.ijk.j+1, cell.ijk.k+1, cell.grid_index))
# Get the grid and dimensions
grid = case.grids()[cell.grid_index]
dimensions = grid.dimensions()
# Map ijk to cell index
cell_index = dimensions.i * dimensions.j * cell.ijk.k + dimensions.i * cell.ijk.j + cell.ijk.i
# Print the cell center
cell_centers = grid.cell_centers()
cell_center = cell_centers[cell_index]
print("Cell center: [{}, {}, {}]".format(cell_center.x, cell_center.y, cell_center.z))
# Print the cell corners
cell_corners = grid.cell_corners()[cell_index]
print("Cell corners:")
print("c0:\n" + str(cell_corners.c0))
print("c1:\n" + str(cell_corners.c1))
print("c2:\n" + str(cell_corners.c2))
print("c3:\n" + str(cell_corners.c3))
print("c4:\n" + str(cell_corners.c4))
print("c5:\n" + str(cell_corners.c5))
print("c6:\n" + str(cell_corners.c6))
print("c7:\n" + str(cell_corners.c7))

21
ApplicationCode/GrpcInterface/Python/rips/case.py
View File

@ -895,3 +895,24 @@ class Case(PdmObject):
for value in chunk.cells:
cell_corners.append(value)
return cell_corners
def selected_cells_async(self):
"""Get the selected cells. Async, so returns an iterator.
Returns:
An iterator to a chunk object containing an array of cells.
Loop through the chunks and then the cells within the chunk to get all cells.
"""
return self.__case_stub.GetSelectedCells(self.__request)
def selected_cells(self):
"""Get the selected cells. Synchronous, so returns a list.
Returns:
A list of Cells.
"""
cells = []
generator = self.selected_cells_async()
for chunk in generator:
for value in chunk.cells:
cells.append(value)
return cells

5
ApplicationCode/GrpcInterface/Python/rips/tests/test_cases.py
View File

@ -172,3 +172,8 @@ def test_exportFlowCharacteristics(rips_instance, initialize_test):
file_name = tmpdirname + "/exportFlowChar.txt"
case.export_flow_characteristics(time_steps=8, producers=[], injectors = "I01", file_name = file_name)
def test_selected_cells(rips_instance, initialize_test):
case = rips_instance.project.load_case(dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID")
assert(case.name == "TEST10K_FLT_LGR_NNC")
selected_cells = case.selected_cells()
assert(len(selected_cells) == 0)

140
ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
View File

@ -26,9 +26,9 @@
#include "RigMainGrid.h"
#include "RimEclipseCase.h"
#include "RimGeoMechCase.h"
#include "RimEclipseResultDefinition.h"
#include <string.h> // memcpy
#include "Riu3dSelectionManager.h"
using namespace rips;
@ -547,6 +547,135 @@ grpc::Status RiaGrpcCaseService::GetCellCornersForActiveCells( grpc::ServerConte
return stateHandler->assignCellCornersReply( reply );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiaSelectedCellsStateHandler::RiaSelectedCellsStateHandler()
: m_request( nullptr )
, m_eclipseCase( nullptr )
, m_currentItem( 0u )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Status RiaSelectedCellsStateHandler::init( const rips::CaseRequest* request )
{
CAF_ASSERT( request );
m_request = request;
RimCase* rimCase = RiaGrpcServiceInterface::findCase( m_request->id() );
m_eclipseCase = dynamic_cast<RimEclipseCase*>( rimCase );
if ( !m_eclipseCase )
{
return grpc::Status( grpc::NOT_FOUND, "Eclipse Case not found" );
}
if ( !m_eclipseCase->eclipseCaseData() || !m_eclipseCase->eclipseCaseData()->mainGrid() )
{
return grpc::Status( grpc::NOT_FOUND, "Eclipse Case Data not found" );
}
return grpc::Status::OK;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Status RiaSelectedCellsStateHandler::assignNextSelectedCell( rips::SelectedCell* cell,
const std::vector<RiuEclipseSelectionItem*>& items )
{
while ( m_currentItem < items.size() )
{
size_t itemToTry = m_currentItem++;
const RiuEclipseSelectionItem* item = items[itemToTry];
CVF_ASSERT( item->type() == RiuSelectionItem::ECLIPSE_SELECTION_OBJECT );
assignSelectedCell( cell, item );
return grpc::Status::OK;
}
return Status( grpc::OUT_OF_RANGE, "We've reached the end. This is not an error but means transmission is finished" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaSelectedCellsStateHandler::assignSelectedCell( rips::SelectedCell* cell, const RiuEclipseSelectionItem* item )
{
CVF_ASSERT( item->type() == RiuSelectionItem::ECLIPSE_SELECTION_OBJECT );
size_t i = -1;
size_t j = -1;
size_t k = -1;
item->m_resultDefinition->eclipseCase()
->eclipseCaseData()
->grid( item->m_gridIndex )
->ijkFromCellIndex( item->m_gridLocalCellIndex, &i, &j, &k );
cell->set_grid_index( item->m_gridIndex );
rips::Vec3i* ijk = new rips::Vec3i;
ijk->set_i( (int)i );
ijk->set_j( (int)j );
ijk->set_k( (int)k );
cell->set_allocated_ijk( ijk );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
grpc::Status RiaSelectedCellsStateHandler::assignReply( rips::SelectedCells* reply )
{
std::vector<RiuSelectionItem*> items;
Riu3dSelectionManager::instance()->selectedItems( items );
// Only eclipse cases are currently supported. Also filter by case.
std::vector<RiuEclipseSelectionItem*> eclipseItems;
for ( auto item : items )
{
RiuEclipseSelectionItem* eclipseItem = dynamic_cast<RiuEclipseSelectionItem*>( item );
if ( eclipseItem && eclipseItem->m_resultDefinition->eclipseCase()->caseId == m_request->id() )
{
eclipseItems.push_back( eclipseItem );
}
}
const size_t packageSize = RiaGrpcServiceInterface::numberOfMessagesForByteCount( sizeof( rips::SelectedCells ) );
size_t packageIndex = 0u;
reply->mutable_cells()->Reserve( (int)packageSize );
for ( ; packageIndex < packageSize && m_currentItem < eclipseItems.size(); ++packageIndex )
{
rips::SelectedCell singleSelectedCell;
grpc::Status singleSelectedCellStatus = assignNextSelectedCell( &singleSelectedCell, eclipseItems );
if ( singleSelectedCellStatus.ok() )
{
rips::SelectedCell* allocSelectedCell = reply->add_cells();
*allocSelectedCell = singleSelectedCell;
}
else
{
break;
}
}
if ( packageIndex > 0u )
{
return Status::OK;
}
return Status( grpc::OUT_OF_RANGE, "We've reached the end. This is not an error but means transmission is finished" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
grpc::Status RiaGrpcCaseService::GetSelectedCells( grpc::ServerContext* context,
const rips::CaseRequest* request,
rips::SelectedCells* reply,
RiaSelectedCellsStateHandler* stateHandler )
{
return stateHandler->assignReply( reply );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -605,6 +734,13 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcCaseService::createCallbacks()
&Self::GetCellCornersForActiveCells,
&Self::RequestGetCellCornersForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CaseRequest,
SelectedCells,
RiaSelectedCellsStateHandler>( this,
&Self::GetSelectedCells,
&Self::RequestGetSelectedCells,
new RiaSelectedCellsStateHandler ),
new RiaGrpcUnaryCallback<Self, CaseRequest, BoundingBox>( this,
&Self::GetReservoirBoundingBox,
&Self::RequestGetReservoirBoundingBox )};

28
ApplicationCode/GrpcInterface/RiaGrpcCaseService.h
View File

@ -34,6 +34,7 @@ class RiaGrpcCallbackInterface;
class RigCell;
class RigActiveCellInfo;
class RimEclipseCase;
class RiuEclipseSelectionItem;
//==================================================================================================
//
@ -76,6 +77,29 @@ protected:
size_t m_currentCellIdx;
};
//==================================================================================================
//
// State handler for streaming of selected cells
//
//==================================================================================================
class RiaSelectedCellsStateHandler
{
typedef grpc::Status Status;
public:
RiaSelectedCellsStateHandler();
Status init( const rips::CaseRequest* request );
Status assignReply( rips::SelectedCells* reply );
void assignSelectedCell( rips::SelectedCell* cell, const RiuEclipseSelectionItem* item );
Status assignNextSelectedCell( rips::SelectedCell* cell, const std::vector<RiuEclipseSelectionItem*>& items );
protected:
const rips::CaseRequest* m_request;
RimEclipseCase* m_eclipseCase;
size_t m_currentItem;
};
//==================================================================================================
//
// gRPC-service answering requests about grid information for a given case
@ -110,6 +134,10 @@ public:
const rips::CellInfoRequest* request,
rips::CellCornersArray* reply,
RiaActiveCellInfoStateHandler* stateHandler );
grpc::Status GetSelectedCells( grpc::ServerContext* context,
const rips::CaseRequest* request,
rips::SelectedCells* reply,
RiaSelectedCellsStateHandler* stateHandler );
grpc::Status GetReservoirBoundingBox( grpc::ServerContext* context,
const rips::CaseRequest* request,
rips::BoundingBox* reply );