mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-10 15:36:09 -06:00
382 lines
16 KiB
C++
382 lines
16 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2019- Equinor ASA
|
|
//
|
|
// ResInsight 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.
|
|
//
|
|
// ResInsight 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.
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////////
|
|
#include "RiaGrpcCaseService.h"
|
|
#include "RiaGrpcCallbacks.h"
|
|
#include "RiaSocketTools.h"
|
|
|
|
#include "RigActiveCellInfo.h"
|
|
#include "RigCaseCellResultsData.h"
|
|
#include "RigEclipseCaseData.h"
|
|
#include "RigEclipseResultAddress.h"
|
|
#include "RigMainGrid.h"
|
|
|
|
#include "RimEclipseCase.h"
|
|
#include "RimGeoMechCase.h"
|
|
|
|
#include <string.h> // memcpy
|
|
|
|
using namespace rips;
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RiaActiveCellInfoStateHandler::RiaActiveCellInfoStateHandler()
|
|
: m_request(nullptr)
|
|
, m_eclipseCase(nullptr)
|
|
, m_activeCellInfo(nullptr)
|
|
, m_currentCellIdx(0u)
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status RiaActiveCellInfoStateHandler::init(const rips::CellInfoRequest* request)
|
|
{
|
|
CAF_ASSERT(request);
|
|
m_request = request;
|
|
|
|
m_porosityModel = RiaDefines::PorosityModelType(m_request->porosity_model());
|
|
RimCase* rimCase = RiaGrpcServiceInterface::findCase(m_request->case_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");
|
|
}
|
|
|
|
m_activeCellInfo = m_eclipseCase->eclipseCaseData()->activeCellInfo(m_porosityModel);
|
|
|
|
if (!m_activeCellInfo)
|
|
{
|
|
return grpc::Status(grpc::NOT_FOUND, "Active Cell Info not found");
|
|
}
|
|
|
|
size_t globalCoarseningBoxCount = 0;
|
|
|
|
for (size_t gridIdx = 0; gridIdx < m_eclipseCase->eclipseCaseData()->gridCount(); gridIdx++)
|
|
{
|
|
m_globalCoarseningBoxIndexStart.push_back(globalCoarseningBoxCount);
|
|
|
|
RigGridBase* grid = m_eclipseCase->eclipseCaseData()->grid(gridIdx);
|
|
|
|
size_t localCoarseningBoxCount = grid->coarseningBoxCount();
|
|
globalCoarseningBoxCount += localCoarseningBoxCount;
|
|
}
|
|
|
|
return grpc::Status::OK;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status RiaActiveCellInfoStateHandler::assignNextActiveCellInfoData(rips::CellInfo* cellInfo)
|
|
{
|
|
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))
|
|
{
|
|
assignCellInfoData(cellInfo, 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");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RiaActiveCellInfoStateHandler::assignCellInfoData(rips::CellInfo* cellInfo,
|
|
const std::vector<RigCell>& reservoirCells,
|
|
size_t cellIdx)
|
|
{
|
|
RigGridBase* grid = reservoirCells[cellIdx].hostGrid();
|
|
CVF_ASSERT(grid != nullptr);
|
|
size_t cellIndex = reservoirCells[cellIdx].gridLocalCellIndex();
|
|
|
|
size_t i, j, k;
|
|
grid->ijkFromCellIndex(cellIndex, &i, &j, &k);
|
|
|
|
size_t pi, pj, pk;
|
|
RigGridBase* parentGrid = nullptr;
|
|
|
|
if (grid->isMainGrid())
|
|
{
|
|
pi = i;
|
|
pj = j;
|
|
pk = k;
|
|
parentGrid = grid;
|
|
}
|
|
else
|
|
{
|
|
size_t parentCellIdx = reservoirCells[cellIdx].parentCellIndex();
|
|
parentGrid = (static_cast<RigLocalGrid*>(grid))->parentGrid();
|
|
CVF_ASSERT(parentGrid != nullptr);
|
|
parentGrid->ijkFromCellIndex(parentCellIdx, &pi, &pj, &pk);
|
|
}
|
|
|
|
cellInfo->set_grid_index((int)grid->gridIndex());
|
|
cellInfo->set_parent_grid_index((int)parentGrid->gridIndex());
|
|
|
|
size_t coarseningIdx = reservoirCells[cellIdx].coarseningBoxIndex();
|
|
if (coarseningIdx != cvf::UNDEFINED_SIZE_T)
|
|
{
|
|
size_t globalCoarseningIdx = m_globalCoarseningBoxIndexStart[grid->gridIndex()] + coarseningIdx;
|
|
cellInfo->set_coarsening_box_index((int)globalCoarseningIdx);
|
|
}
|
|
else
|
|
{
|
|
cellInfo->set_coarsening_box_index(-1);
|
|
}
|
|
{
|
|
rips::Vec3i* local_ijk = new rips::Vec3i;
|
|
local_ijk->set_i((int)i);
|
|
local_ijk->set_j((int)j);
|
|
local_ijk->set_k((int)k);
|
|
cellInfo->set_allocated_local_ijk(local_ijk);
|
|
}
|
|
{
|
|
rips::Vec3i* parent_ijk = new rips::Vec3i;
|
|
parent_ijk->set_i((int)pi);
|
|
parent_ijk->set_j((int)pj);
|
|
parent_ijk->set_k((int)pk);
|
|
cellInfo->set_allocated_parent_ijk(parent_ijk);
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RigActiveCellInfo* RiaActiveCellInfoStateHandler::activeCellInfo() const
|
|
{
|
|
return m_activeCellInfo;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
const std::vector<RigCell>& RiaActiveCellInfoStateHandler::reservoirCells() const
|
|
{
|
|
const std::vector<RigCell>& reservoirCells = m_eclipseCase->eclipseCaseData()->mainGrid()->globalCellArray();
|
|
return reservoirCells;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status RiaActiveCellInfoStateHandler::assignReply(rips::CellInfoArray* reply)
|
|
{
|
|
const size_t packageSize = RiaGrpcServiceInterface::numberOfMessagesForByteCount(sizeof(rips::CellInfoArray));
|
|
size_t packageIndex = 0u;
|
|
reply->mutable_data()->Reserve((int)packageSize);
|
|
for (; packageIndex < packageSize && m_currentCellIdx < m_activeCellInfo->reservoirCellCount(); ++packageIndex)
|
|
{
|
|
rips::CellInfo singleCellInfo;
|
|
grpc::Status singleCellInfoStatus = assignNextActiveCellInfoData(&singleCellInfo);
|
|
if (singleCellInfoStatus.ok())
|
|
{
|
|
rips::CellInfo* allocCellInfo = reply->add_data();
|
|
*allocCellInfo = singleCellInfo;
|
|
}
|
|
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::GetGridCount(grpc::ServerContext* context, const rips::CaseRequest* request, rips::GridCount* reply)
|
|
{
|
|
RimCase* rimCase = findCase(request->id());
|
|
|
|
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(rimCase);
|
|
if (eclipseCase)
|
|
{
|
|
int gridCount = (int) eclipseCase->mainGrid()->gridCount();
|
|
reply->set_count(gridCount);
|
|
return Status::OK;
|
|
}
|
|
return grpc::Status(grpc::NOT_FOUND, "Eclipse Case not found");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status RiaGrpcCaseService::GetCellCount(grpc::ServerContext* context, const rips::CellInfoRequest* request, rips::CellCount* reply)
|
|
{
|
|
RimCase* rimCase = findCase(request->case_request().id());
|
|
|
|
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(rimCase);
|
|
if (eclipseCase)
|
|
{
|
|
auto porosityModel = RiaDefines::PorosityModelType(request->porosity_model());
|
|
RigActiveCellInfo* activeCellInfo = eclipseCase->eclipseCaseData()->activeCellInfo(porosityModel);
|
|
reply->set_active_cell_count((int) activeCellInfo->reservoirActiveCellCount());
|
|
reply->set_reservoir_cell_count((int) activeCellInfo->reservoirCellCount());
|
|
return grpc::Status::OK;
|
|
}
|
|
return grpc::Status(grpc::NOT_FOUND, "Eclipse Case not found");
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status
|
|
RiaGrpcCaseService::GetTimeSteps(grpc::ServerContext* context, const rips::CaseRequest* request, rips::TimeStepDates* reply)
|
|
{
|
|
RimCase* rimCase = findCase(request->id());
|
|
|
|
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(rimCase);
|
|
if (eclipseCase)
|
|
{
|
|
std::vector<QDateTime> timeStepDates = eclipseCase->timeStepDates();
|
|
for (QDateTime dateTime : timeStepDates)
|
|
{
|
|
rips::TimeStepDate* date = reply->add_dates();
|
|
date->set_year(dateTime.date().year());
|
|
date->set_month(dateTime.date().month());
|
|
date->set_day(dateTime.date().day());
|
|
date->set_hour(dateTime.time().hour());
|
|
date->set_minute(dateTime.time().minute());
|
|
date->set_second(dateTime.time().second());
|
|
}
|
|
return grpc::Status::OK;
|
|
}
|
|
return grpc::Status(grpc::NOT_FOUND, "Eclipse Case not found");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status RiaGrpcCaseService::GetDaysSinceStart(grpc::ServerContext* context,
|
|
const rips::CaseRequest* request,
|
|
rips::DaysSinceStart* reply)
|
|
{
|
|
RimCase* rimCase = findCase(request->id());
|
|
|
|
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(rimCase);
|
|
if (eclipseCase)
|
|
{
|
|
RigEclipseResultAddress addrToMaxTimeStepCountResult;
|
|
if (eclipseCase && eclipseCase->eclipseCaseData())
|
|
{
|
|
eclipseCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->maxTimeStepCount(&addrToMaxTimeStepCountResult);
|
|
if (!addrToMaxTimeStepCountResult.isValid())
|
|
{
|
|
return grpc::Status(grpc::NOT_FOUND, "Invalid result. No time steps found.");
|
|
}
|
|
}
|
|
|
|
std::vector<double> daysSinceSimulationStart =
|
|
eclipseCase->eclipseCaseData()->results(RiaDefines::MATRIX_MODEL)->daysSinceSimulationStart(addrToMaxTimeStepCountResult);
|
|
|
|
for (auto days : daysSinceSimulationStart)
|
|
{
|
|
reply->add_day_decimals(days);
|
|
}
|
|
return grpc::Status::OK;
|
|
}
|
|
return grpc::Status(grpc::NOT_FOUND, "Eclipse Case not found");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status
|
|
RiaGrpcCaseService::GetCaseInfo(grpc::ServerContext* context, const rips::CaseRequest* request, rips::CaseInfo* reply)
|
|
{
|
|
RimCase* rimCase = findCase(request->id());
|
|
if (rimCase)
|
|
{
|
|
qint64 caseId = rimCase->caseId();
|
|
qint64 caseGroupId = -1;
|
|
QString caseName, caseType;
|
|
RiaSocketTools::getCaseInfoFromCase(rimCase, caseId, caseName, caseType, caseGroupId);
|
|
|
|
reply->set_id(caseId);
|
|
reply->set_group_id(caseGroupId);
|
|
reply->set_name(caseName.toStdString());
|
|
reply->set_type(caseType.toStdString());
|
|
return Status::OK;
|
|
}
|
|
return Status(grpc::NOT_FOUND, "No cases found");
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status
|
|
RiaGrpcCaseService::GetPdmObject(grpc::ServerContext* context, const rips::CaseRequest* request, rips::PdmObject* reply)
|
|
{
|
|
RimCase* rimCase = findCase(request->id());
|
|
RimEclipseCase* eclipseCase = dynamic_cast<RimEclipseCase*>(rimCase);
|
|
if (eclipseCase)
|
|
{
|
|
copyPdmObjectFromCafToRips(eclipseCase, reply);
|
|
}
|
|
return grpc::Status::OK;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
grpc::Status RiaGrpcCaseService::GetCellInfoForActiveCells(grpc::ServerContext* context,
|
|
const rips::CellInfoRequest* request,
|
|
rips::CellInfoArray* reply,
|
|
RiaActiveCellInfoStateHandler* stateHandler)
|
|
{
|
|
return stateHandler->assignReply(reply);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
std::vector<RiaGrpcCallbackInterface*> RiaGrpcCaseService::createCallbacks()
|
|
{
|
|
typedef RiaGrpcCaseService Self;
|
|
|
|
return {new RiaGrpcUnaryCallback<Self, CaseRequest, GridCount>(this, &Self::GetGridCount, &Self::RequestGetGridCount),
|
|
new RiaGrpcUnaryCallback<Self, CellInfoRequest, CellCount>(this, &Self::GetCellCount, &Self::RequestGetCellCount),
|
|
new RiaGrpcUnaryCallback<Self, CaseRequest, TimeStepDates>(this, &Self::GetTimeSteps, &Self::RequestGetTimeSteps),
|
|
new RiaGrpcUnaryCallback<Self, CaseRequest, DaysSinceStart>(this, &Self::GetDaysSinceStart, &Self::RequestGetDaysSinceStart),
|
|
new RiaGrpcUnaryCallback<Self, CaseRequest, CaseInfo>(this, &Self::GetCaseInfo, &Self::RequestGetCaseInfo),
|
|
new RiaGrpcUnaryCallback<Self, CaseRequest, PdmObject>(this, &Self::GetPdmObject, &Self::RequestGetPdmObject),
|
|
new RiaGrpcServerToClientStreamCallback<Self, CellInfoRequest, CellInfoArray, RiaActiveCellInfoStateHandler>(
|
|
this, &Self::GetCellInfoForActiveCells, &Self::RequestGetCellInfoForActiveCells, new RiaActiveCellInfoStateHandler)};
|
|
}
|
|
|
|
static bool RiaGrpcCaseService_init =
|
|
RiaGrpcServiceFactory::instance()->registerCreator<RiaGrpcCaseService>(typeid(RiaGrpcCaseService).hash_code());
|