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 cell corners for active cells

Browse Source 
Equivalent to GetActiveCellCorners in Octave.
This commit is contained in:
Kristian Bendiksen
2020-02-19 11:33:25 +01:00
parent c20c3bc2ac
commit c64281c525
5 changed files with 174 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -11,6 +11,7 @@ service Case
rpc GetCellCount(CellInfoRequest) returns (CellCount) {}
rpc GetCellInfoForActiveCells(CellInfoRequest) returns (stream CellInfoArray) {}
rpc GetCellCenterForActiveCells(CellInfoRequest) returns (stream CellCenters) {}
rpc GetCellCornersForActiveCells(CellInfoRequest) returns (stream CellCornersArray) {}
rpc GetCoarseningInfoArray(CaseRequest) returns (CoarseningInfoArray) {}
rpc GetTimeSteps(CaseRequest) returns (TimeStepDates) {}
rpc GetDaysSinceStart(CaseRequest) returns (DaysSinceStart) {}

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

@@ -858,3 +858,40 @@ class Case(PdmObject):
for value in chunk.centers:
cell_centers.append(value)
return cell_centers
def active_cell_corners_async(
self,
porosity_model="MATRIX_MODEL",
):
"""Get a cell corners for all active cells. Async, so returns an iterator
Arguments:
porosity_model(str): string enum. See available()
Returns:
An iterator to a chunk object containing an array of CellCorners (which is eight Vec3d values).
Loop through the chunks and then the values within the chunk to get all values.
"""
porosity_model_enum = Case_pb2.PorosityModelType.Value(porosity_model)
request = Case_pb2.CellInfoRequest(case_request=self.__request,
porosity_model=porosity_model_enum)
return self.__case_stub.GetCellCornersForActiveCells(request)
def active_cell_corners(
self,
porosity_model="MATRIX_MODEL",
):
"""Get a cell corners for all active cells. Synchronous, so returns a list.
Arguments:
porosity_model(str): string enum. See available()
Returns:
A list of CellCorners
"""
cell_corners = []
generator = self.active_cell_corners_async(porosity_model)
for chunk in generator:
for value in chunk.cells:
cell_corners.append(value)
return cell_corners

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

@@ -62,6 +62,11 @@ def get_cell_index_with_ijk(cell_info, i, j, k):
return idx
return -1
def check_corner(actual, expected):
assert(math.isclose(actual.x, expected[0], abs_tol=0.1))
assert(math.isclose(actual.y, expected[1], abs_tol=0.1))
assert(math.isclose(actual.z, expected[2], abs_tol=0.1))
def test_10k(rips_instance, initialize_test):
case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
case = rips_instance.project.load_case(path=case_path)
@@ -88,6 +93,26 @@ def test_10k(rips_instance, initialize_test):
assert(math.isclose(5209.75, cell_centers[cell_index].y, abs_tol=0.1))
assert(math.isclose(4179.6, cell_centers[cell_index].z, abs_tol=0.1))
cell_corners = case.active_cell_corners()
assert(len(cell_corners) == cell_count_info.active_cell_count)
# Expected values from ResInsight UI
expected_corners = [[ 3565.22, 5179.02, 4177.18],
[ 3655.67, 5145.34, 4176.63],
[ 3690.07, 5240.69, 4180.02],
[ 3599.87, 5275.16, 4179.32],
[ 3564.13, 5178.61, 4179.75],
[ 3654.78, 5144.79, 4179.23],
[ 3688.99, 5239.88, 4182.7],
[ 3598.62, 5274.48, 4181.96]]
check_corner(cell_corners[cell_index].c0, expected_corners[0])
check_corner(cell_corners[cell_index].c1, expected_corners[1])
check_corner(cell_corners[cell_index].c2, expected_corners[2])
check_corner(cell_corners[cell_index].c3, expected_corners[3])
check_corner(cell_corners[cell_index].c4, expected_corners[4])
check_corner(cell_corners[cell_index].c5, expected_corners[5])
check_corner(cell_corners[cell_index].c6, expected_corners[6])
check_corner(cell_corners[cell_index].c7, expected_corners[7])
def test_PdmObject(rips_instance, initialize_test):
case_path = dataroot.PATH + "/TEST10K_FLT_LGR_NNC/TEST10K_FLT_LGR_NNC.EGRID"
case = rips_instance.project.load_case(path=case_path)

103
ApplicationCode/GrpcInterface/RiaGrpcCaseService.cpp
View File

@@ -290,6 +290,90 @@ grpc::Status RiaActiveCellInfoStateHandler::assignCellCentersReply( rips::CellCe
return Status( grpc::OUT_OF_RANGE, "We've reached the end. This is not an error but means transmission is finished" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Status RiaActiveCellInfoStateHandler::assignNextActiveCellCorners( rips::CellCorners* cellCorners )
{
const std::vector<RigCell>& reservoirCells = m_eclipseCase->eclipseCaseData()->mainGrid()->globalCellArray();
while ( m_currentCellIdx < reservoirCells.size() )
{
size_t cellIdxToTry = m_currentCellIdx++;
if ( m_activeCellInfo->isActive( cellIdxToTry ) )
{
assignCellCorners( cellCorners, reservoirCells, cellIdxToTry );
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" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
// TODO: duped with TestGrpcGridService
void setCornerValues2( rips::Vec3d* out, const cvf::Vec3d& in )
{
out->set_x( in.x() );
out->set_y( in.y() );
out->set_z( in.z() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaActiveCellInfoStateHandler::assignCellCorners( rips::CellCorners* corners,
const std::vector<RigCell>& reservoirCells,
size_t cellIdx )
{
cvf::Vec3d cornerVerts[8];
RigGridBase* grid = m_eclipseCase->eclipseCaseData()->mainGrid();
grid->cellCornerVertices( cellIdx, cornerVerts );
for ( cvf::Vec3d& corner : cornerVerts )
{
convertVec3dToPositiveDepth( &corner );
}
setCornerValues2( corners->mutable_c0(), cornerVerts[0] );
setCornerValues2( corners->mutable_c1(), cornerVerts[1] );
setCornerValues2( corners->mutable_c2(), cornerVerts[2] );
setCornerValues2( corners->mutable_c3(), cornerVerts[3] );
setCornerValues2( corners->mutable_c4(), cornerVerts[4] );
setCornerValues2( corners->mutable_c5(), cornerVerts[5] );
setCornerValues2( corners->mutable_c6(), cornerVerts[6] );
setCornerValues2( corners->mutable_c7(), cornerVerts[7] );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Status RiaActiveCellInfoStateHandler::assignCellCornersReply( rips::CellCornersArray* reply )
{
const size_t packageSize = RiaGrpcServiceInterface::numberOfMessagesForByteCount( sizeof( rips::CellCornersArray ) );
size_t packageIndex = 0u;
reply->mutable_cells()->Reserve( (int)packageSize );
for ( ; packageIndex < packageSize && m_currentCellIdx < m_activeCellInfo->reservoirCellCount(); ++packageIndex )
{
rips::CellCorners singleCellCorners;
grpc::Status singleCellCornersStatus = assignNextActiveCellCorners( &singleCellCorners );
if ( singleCellCornersStatus.ok() )
{
rips::CellCorners* allocCellCorners = reply->add_cells();
*allocCellCorners = singleCellCorners;
}
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" );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -452,6 +536,17 @@ grpc::Status RiaGrpcCaseService::GetCellCenterForActiveCells( grpc::ServerContex
return stateHandler->assignCellCentersReply( reply );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
grpc::Status RiaGrpcCaseService::GetCellCornersForActiveCells( grpc::ServerContext* context,
const rips::CellInfoRequest* request,
rips::CellCornersArray* reply,
RiaActiveCellInfoStateHandler* stateHandler )
{
return stateHandler->assignCellCornersReply( reply );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -503,7 +598,13 @@ std::vector<RiaGrpcCallbackInterface*> RiaGrpcCaseService::createCallbacks()
&Self::GetCellCenterForActiveCells,
&Self::RequestGetCellCenterForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcServerToClientStreamCallback<Self,
CellInfoRequest,
CellCornersArray,
RiaActiveCellInfoStateHandler>( this,
&Self::GetCellCornersForActiveCells,
&Self::RequestGetCellCornersForActiveCells,
new RiaActiveCellInfoStateHandler ),
new RiaGrpcUnaryCallback<Self, CaseRequest, BoundingBox>( this,
&Self::GetReservoirBoundingBox,
&Self::RequestGetReservoirBoundingBox )};

9
ApplicationCode/GrpcInterface/RiaGrpcCaseService.h
View File

@@ -62,6 +62,11 @@ public:
void assignCellCenter( rips::Vec3d* cellCenter, const std::vector<RigCell>& reservoirCells, size_t cellIdx );
Status assignCellCentersReply( rips::CellCenters* reply );
// For cell corners:
Status assignNextActiveCellCorners( rips::CellCorners* cellCorners );
void assignCellCorners( rips::CellCorners* cellCorners, const std::vector<RigCell>& reservoirCells, size_t cellIdx );
Status assignCellCornersReply( rips::CellCornersArray* reply );
protected:
const rips::CellInfoRequest* m_request;
RimEclipseCase* m_eclipseCase;
@@ -101,6 +106,10 @@ public:
const rips::CellInfoRequest* request,
rips::CellCenters* reply,
RiaActiveCellInfoStateHandler* stateHandler );
grpc::Status GetCellCornersForActiveCells( grpc::ServerContext* context,
const rips::CellInfoRequest* request,
rips::CellCornersArray* reply,
RiaActiveCellInfoStateHandler* stateHandler );
grpc::Status GetReservoirBoundingBox( grpc::ServerContext* context,
const rips::CaseRequest* request,
rips::BoundingBox* reply );