OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-01-03 20:57:39 -06:00
Code Issues Packages Projects Releases Wiki Activity
4719090b5f
ResInsight/ApplicationLibCode/ReservoirDataModel/RigSimulationWellCenterLineCalculator.cpp
jonjenssen 0572069511
Support for loading only active cell geometry (#11624) 
* Only load active cells for main grid, skip LGRs for now
* Handle wells with inactive cells
* Validate mapaxes transform before using it.
* Add log message
* Additional guarding when trying to find the geometrical location of a simulation cell
* Add extra safeguarding for init/restart file access in opm common. Only support unified restart files.
2024-08-28 18:22:57 +02:00

585 lines
27 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) Statoil ASA
// Copyright (C) Ceetron Solutions AS
//
// 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 "RigSimulationWellCenterLineCalculator.h"
#include "RiaLogging.h"
#include "RigCell.h"
#include "RigCellFaceGeometryTools.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RigSimWellData.h"
#include "RigWellResultFrame.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimSimWellInView.h"
#include "RimSimWellInViewCollection.h"
#include "cvfBoundingBoxTree.h"
#include "cvfGeometryTools.h"
#include "cvfRay.h"
#include <deque>
#include <list>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<SimulationWellCellBranch> RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline( const RimSimWellInView* rimWell )
{
std::vector<std::vector<cvf::Vec3d>> pipeBranchesCLCoords;
std::vector<std::vector<RigWellResultPoint>> pipeBranchesCellIds;
calculateWellPipeStaticCenterline( rimWell, pipeBranchesCLCoords, pipeBranchesCellIds );
std::vector<SimulationWellCellBranch> simuationBranches;
for ( size_t i = 0; i < pipeBranchesCLCoords.size(); i++ )
{
if ( i < pipeBranchesCellIds.size() )
{
simuationBranches.emplace_back( std::make_pair( pipeBranchesCLCoords[i], pipeBranchesCellIds[i] ) );
}
}
return simuationBranches;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<SimulationWellCellBranch>
RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineForTimeStep( const RigEclipseCaseData* eclipseCaseData,
const RigSimWellData* simWellData,
int timeStepIndex,
bool isAutoDetectBranches,
bool useAllCellCenters )
{
std::vector<std::vector<cvf::Vec3d>> pipeBranchesCLCoords;
std::vector<std::vector<RigWellResultPoint>> pipeBranchesCellIds;
calculateWellPipeCenterlineForTimeStep( eclipseCaseData,
simWellData,
timeStepIndex,
isAutoDetectBranches,
useAllCellCenters,
pipeBranchesCLCoords,
pipeBranchesCellIds );
std::vector<SimulationWellCellBranch> simuationBranches;
for ( size_t i = 0; i < pipeBranchesCLCoords.size(); i++ )
{
if ( i < pipeBranchesCellIds.size() )
{
simuationBranches.emplace_back( std::make_pair( pipeBranchesCLCoords[i], pipeBranchesCellIds[i] ) );
}
}
return simuationBranches;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<std::vector<std::vector<cvf::Vec3d>>, std::vector<std::vector<RigWellResultPoint>>>
RigSimulationWellCenterLineCalculator::extractBranchData( const std::vector<SimulationWellCellBranch> simulationBranch )
{
std::vector<std::vector<cvf::Vec3d>> pipeBranchesCLCoords;
std::vector<std::vector<RigWellResultPoint>> pipeBranchesCellIds;
for ( const auto& [coords, wellCells] : simulationBranch )
{
pipeBranchesCLCoords.emplace_back( coords );
pipeBranchesCellIds.emplace_back( wellCells );
}
return { pipeBranchesCLCoords, pipeBranchesCellIds };
}
//--------------------------------------------------------------------------------------------------
/// Based on the points and cells, calculate a pipe centerline
/// The returned CellIds is one less than the number of centerline points,
/// and are describing the lines between the points, starting with the first line
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeStaticCenterline( const RimSimWellInView* rimWell,
std::vector<std::vector<cvf::Vec3d>>& pipeBranchesCLCoords,
std::vector<std::vector<RigWellResultPoint>>& pipeBranchesCellIds )
{
CVF_ASSERT( rimWell );
const RigSimWellData* simWellData = rimWell->simWellData();
if ( !simWellData ) return;
auto eclipseView = rimWell->firstAncestorOrThisOfTypeAsserted<RimEclipseView>();
RigEclipseCaseData* eclipseCaseData = eclipseView->eclipseCase()->eclipseCaseData();
bool isAutoDetectBranches = eclipseView->wellCollection()->isAutoDetectingBranches();
bool useAllCellCenters = rimWell->isUsingCellCenterForPipe();
int timeStepIndex = -1;
calculateWellPipeCenterlineForTimeStep( eclipseCaseData,
simWellData,
timeStepIndex,
isAutoDetectBranches,
useAllCellCenters,
pipeBranchesCLCoords,
pipeBranchesCellIds );
// DEBUG output, please keep code
bool printDebug = false;
if ( printDebug )
{
QString txt;
for ( size_t idx = 0; idx < pipeBranchesCellIds.size(); idx++ )
{
const auto& branchCells = pipeBranchesCellIds[idx];
for ( const auto& resultPoint : branchCells )
{
QString myTxt;
int fieldWidth = 3;
myTxt += QString( "Ri branch index: %1 " ).arg( idx, fieldWidth );
myTxt += QString( "Seg: %1 Branch: %2 " ).arg( resultPoint.segmentId(), fieldWidth ).arg( resultPoint.branchId(), fieldWidth );
if ( resultPoint.isCell() )
{
size_t i = 0, j = 0, k = 0;
auto grid = eclipseCaseData->grid( resultPoint.gridIndex() );
grid->ijkFromCellIndex( resultPoint.cellIndex(), &i, &j, &k );
myTxt += QString( "Grid %1 %2 %3 " ).arg( i + 1, fieldWidth ).arg( j + 1, fieldWidth ).arg( k + 1, fieldWidth );
}
myTxt += QString( "OutSeg: %1 OutBranch: %2 " )
.arg( resultPoint.outletSegmentId(), fieldWidth )
.arg( resultPoint.outletBranchId(), fieldWidth );
int coordFieldWidth = 12;
myTxt += QString( "Bottom pos: %1 %2 %3 " )
.arg( resultPoint.bottomPosition().x(), coordFieldWidth )
.arg( resultPoint.bottomPosition().y(), coordFieldWidth )
.arg( resultPoint.bottomPosition().z(), coordFieldWidth );
myTxt += "\n";
txt += myTxt;
}
}
RiaLogging::debug( txt );
}
}
//--------------------------------------------------------------------------------------------------
/// Based on the points and cells, calculate a pipe centerline
/// The returned CellIds is one less than the number of centerline points,
/// and are describing the lines between the points, starting with the first line
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::calculateWellPipeCenterlineForTimeStep( const RigEclipseCaseData* eclipseCaseData,
const RigSimWellData* wellResults,
int timeStepIndex,
bool isAutoDetectBranches,
bool useAllCellCenters,
std::vector<std::vector<cvf::Vec3d>>& pipeBranchesCLCoords,
std::vector<std::vector<RigWellResultPoint>>& pipeBranchesCellIds )
{
// Initialize the return arrays
pipeBranchesCLCoords.clear();
pipeBranchesCellIds.clear();
if ( !wellResults ) return;
if ( timeStepIndex >= 0 && !wellResults->hasAnyValidCells( timeStepIndex ) ) return;
const RigWellResultFrame* wellFramePtr = nullptr;
if ( timeStepIndex < 0 )
{
wellFramePtr = wellResults->staticWellResultFrame();
}
else
{
wellFramePtr = wellResults->wellResultFrame( timeStepIndex );
}
bool isMultiSegmentWell = wellResults->isMultiSegmentWell();
const RigWellResultFrame& wellFrame = *wellFramePtr;
const std::vector<RigWellResultBranch> resBranches = wellFrame.wellResultBranches();
const bool debugOutput = false;
if ( debugOutput )
{
for ( const auto& branch : resBranches )
{
QString branchTxt;
for ( const auto& resultPoint : branch.branchResultPoints() )
{
if ( resultPoint.cellIjk().has_value() )
{
branchTxt += QString( " %1 \n" ).arg( QString::fromStdString( ( *resultPoint.cellIjk() ).toString() ) );
}
}
RiaLogging::debug( branchTxt );
}
}
// Well head
// Match this position with well head position in RivWellHeadPartMgr::buildWellHeadParts()
auto wellPoint = wellFrame.wellHeadOrStartCell();
if ( !wellPoint.isCell() ) return;
const RigCell& whCell = eclipseCaseData->cellFromWellResultCell( wellPoint );
cvf::Vec3d whStartPos = whCell.faceCenter( cvf::StructGridInterface::NEG_K );
RigWellResultPoint wellHead = wellFrame.wellHeadOrStartCell();
const RigWellResultPoint* whResCell = &wellHead;
// Add extra coordinate between cell face and cell center
// to make sure the well pipe terminated in a segment parallel to z-axis
cvf::Vec3d whIntermediate = whStartPos;
whIntermediate.z() = ( whStartPos.z() + whCell.center().z() ) / 2.0;
const RigWellResultPoint* prevWellResPoint = nullptr;
// CVF_ASSERT(isMultiSegmentWell || resBranches.size() <= 1); // TODO : Consider to set isMultiSegmentWell = true;
// The centerline is calculated by adding a point when the pipe enters a cell,
// and one when the line leaves the cell.
// For the sake of the loop:
// The currentResultPoint (Cell) and the one we index by the loop variable is the one we calculate the entry point
// to. The previous cell is the one we leave, and calculate the "out-point" from
for ( size_t brIdx = 0; brIdx < resBranches.size(); brIdx++ )
{
// Skip empty branches. Do not know why they exist, but they make problems.
const RigWellResultBranch& branch = resBranches[brIdx];
if ( !hasAnyValidDataCells( branch ) ) continue;
prevWellResPoint = nullptr;
// Find the start the MSW well-branch centerline. Normal wells are started "once" at wellhead in the code above
pipeBranchesCLCoords.push_back( std::vector<cvf::Vec3d>() );
pipeBranchesCellIds.push_back( std::vector<RigWellResultPoint>() );
if ( brIdx == 0 )
{
// The first branch contains segment number 1, and this is the only segment connected to well head
// See Eclipse documentation for the keyword WELSEGS
prevWellResPoint = whResCell;
pipeBranchesCLCoords.back().push_back( whStartPos );
pipeBranchesCellIds.back().push_back( *prevWellResPoint );
pipeBranchesCLCoords.back().push_back( whIntermediate );
pipeBranchesCellIds.back().push_back( *prevWellResPoint );
}
// Loop over all the resultPoints in the branch
const std::vector<RigWellResultPoint> resBranchCells = resBranches[brIdx].branchResultPoints();
for ( int cIdx = 0; cIdx < static_cast<int>( resBranchCells.size() ); cIdx++ ) // Need int because cIdx can
// temporarily end on
// cvf::UNDEFINED_SIZE_T
{
std::vector<cvf::Vec3d>& branchCLCoords = pipeBranchesCLCoords.back();
std::vector<RigWellResultPoint>& branchCellIds = pipeBranchesCellIds.back();
const RigWellResultPoint& currentWellResPoint = resBranchCells[cIdx];
// Ignore invalid cells
if ( !currentWellResPoint.isValid() )
{
// CVF_ASSERT(false); // Some segments does not get anything yet.
continue;
}
// Add cl contribution for a geometrical resultPoint by adding exit point from previous cell,
// and then the result point position
if ( !currentWellResPoint.isCell() )
{
// Use the interpolated value of branch head
CVF_ASSERT( currentWellResPoint.isPointValid() );
cvf::Vec3d currentPoint = currentWellResPoint.bottomPosition();
// If we have a real previous cell, we need to go out of it, before adding the current point
// That is: add a CL-point describing where it leaves the previous cell.
if ( prevWellResPoint && prevWellResPoint->isCell() )
{
// Create ray between the previous and this position
const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell( *prevWellResPoint );
cvf::Vec3d centerPreviousCell = prevCell.center();
cvf::Ray rayToThisCell;
rayToThisCell.setOrigin( centerPreviousCell );
rayToThisCell.setDirection( ( currentPoint - centerPreviousCell ).getNormalized() );
cvf::Vec3d outOfPrevCell( centerPreviousCell );
prevCell.firstIntersectionPoint( rayToThisCell, &outOfPrevCell );
if ( ( currentPoint - outOfPrevCell ).lengthSquared() > 1e-3 )
{
branchCLCoords.push_back( outOfPrevCell );
branchCellIds.push_back( RigWellResultPoint() );
}
}
branchCLCoords.push_back( currentPoint );
branchCellIds.push_back( currentWellResPoint );
prevWellResPoint = &currentWellResPoint;
continue;
}
//
// Handle currentWellResPoint as a real cell result points.
//
const RigCell& cell = eclipseCaseData->cellFromWellResultCell( currentWellResPoint );
// Check if this and the previous cells has shared faces
cvf::StructGridInterface::FaceType sharedFace;
if ( prevWellResPoint && prevWellResPoint->isCell() &&
eclipseCaseData->findSharedSourceFace( sharedFace, currentWellResPoint, *prevWellResPoint ) )
{
// If they share faces, the shared face center is used as point
// describing the entry of this cell. (And exit of the previous cell)
branchCLCoords.push_back( cell.faceCenter( sharedFace ) );
branchCellIds.push_back( currentWellResPoint );
}
else
{
// This and the previous cell does not share a face.
// Then we need to calculate the exit of the previous cell, and the entry point into this cell
cvf::Vec3d centerPreviousCell( cvf::Vec3d::ZERO );
cvf::Vec3d centerThisCell = cell.center();
bool distanceToWellHeadIsLonger = true;
// If we have a previous well result point, use its center as measure point and ray intersection start
// when considering things.
if ( prevWellResPoint && prevWellResPoint->isValid() )
{
if ( prevWellResPoint->isCell() )
{
const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell( *prevWellResPoint );
centerPreviousCell = prevCell.center();
}
else
{
centerPreviousCell = prevWellResPoint->bottomPosition();
}
distanceToWellHeadIsLonger = ( centerThisCell - centerPreviousCell ).lengthSquared() <=
( centerThisCell - whStartPos ).lengthSquared();
}
// First make sure this cell is not starting a new "display" branch for none MSW's
if ( isMultiSegmentWell || !isAutoDetectBranches || ( prevWellResPoint == whResCell ) || distanceToWellHeadIsLonger )
{
// Not starting a "display" branch for normal wells
// Calculate the exit of the previous cell, and the entry point into this cell
cvf::Vec3d intoThisCell( centerThisCell ); // Use cell center as default for "into" point.
if ( prevWellResPoint && prevWellResPoint->isValid() )
{
// We have a defined previous point
// Create ray between the previous and this cell
cvf::Ray rayToThisCell;
rayToThisCell.setOrigin( centerPreviousCell );
rayToThisCell.setDirection( ( centerThisCell - centerPreviousCell ).getNormalized() );
// Intersect with the current cell to find a better entry point than the cell center
int intersectionCount = cell.firstIntersectionPoint( rayToThisCell, &intoThisCell );
bool isPreviousResPointInsideCurrentCell = ( intersectionCount % 2 ); // Must intersect uneven
// times to be inside. (1
// % 2 = 1)
// If we have a real previous cell, we need to go out of it, before entering this.
// That is: add a CL-point describing where it leaves the previous cell.
if ( prevWellResPoint->isCell() )
{
cvf::Vec3d outOfPrevCell( centerPreviousCell );
const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell( *prevWellResPoint );
prevCell.firstIntersectionPoint( rayToThisCell, &outOfPrevCell );
if ( ( intoThisCell - outOfPrevCell ).lengthSquared() > 1e-3 )
{
branchCLCoords.push_back( outOfPrevCell );
branchCellIds.push_back( RigWellResultPoint() );
}
}
else if ( isPreviousResPointInsideCurrentCell )
{
// Since the previous point actually is inside this cell,
/// use that as the entry point into this cell
intoThisCell = centerPreviousCell;
}
}
branchCLCoords.push_back( intoThisCell );
branchCellIds.push_back( currentWellResPoint );
}
else
{
// Need to start a "display branch" for a Normal Well.
CVF_ASSERT( !isMultiSegmentWell );
// This cell is further from the previous cell than from the well head,
// thus we interpret it as a new branch.
// First finish the current branch in the previous cell
// branchCLCoords.push_back(branchCLCoords.back() + 1.5*(centerPreviousCell - branchCLCoords.back()) );
finishPipeCenterLine( pipeBranchesCLCoords, centerPreviousCell );
// Create new display branch
pipeBranchesCLCoords.push_back( std::vector<cvf::Vec3d>() );
pipeBranchesCellIds.push_back( std::vector<RigWellResultPoint>() );
// Start the new branch by entering the first cell (the wellhead) and intermediate
prevWellResPoint = whResCell;
pipeBranchesCLCoords.back().push_back( whStartPos );
pipeBranchesCellIds.back().push_back( *prevWellResPoint );
// Include intermediate
pipeBranchesCLCoords.back().push_back( whIntermediate );
pipeBranchesCellIds.back().push_back( *prevWellResPoint );
// Well now we need to step one back to take this cell again, but in the new branch.
cIdx--;
continue;
}
}
prevWellResPoint = &currentWellResPoint;
}
// For the last cell, add the point 0.5 past the center of that cell
// Remember that prevWellResPoint actually is the last one in this branch.
if ( prevWellResPoint && prevWellResPoint->isCell() )
{
const RigCell& prevCell = eclipseCaseData->cellFromWellResultCell( *prevWellResPoint );
cvf::Vec3d centerLastCell = prevCell.center();
finishPipeCenterLine( pipeBranchesCLCoords, centerLastCell );
}
else if ( prevWellResPoint && prevWellResPoint->isPointValid() )
{
// Continue the line with the same point, just to keep the last Cell ID
pipeBranchesCLCoords.back().push_back( prevWellResPoint->bottomPosition() );
}
else
{
// Remove the ID that is superfluous since we will not add an ending point
pipeBranchesCellIds.back().pop_back();
}
}
if ( useAllCellCenters ) addCellCenterPoints( eclipseCaseData, pipeBranchesCLCoords, pipeBranchesCellIds );
CVF_ASSERT( pipeBranchesCellIds.size() == pipeBranchesCLCoords.size() );
for ( size_t i = 0; i < pipeBranchesCellIds.size(); ++i )
{
CVF_ASSERT( pipeBranchesCellIds[i].size() == pipeBranchesCLCoords[i].size() - 1 );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::addCellCenterPoints( const RigEclipseCaseData* eclipseCaseData,
std::vector<std::vector<cvf::Vec3d>>& pipeBranchesCLCoords,
std::vector<std::vector<RigWellResultPoint>>& pipeBranchesCellIds )
{
for ( size_t brIdx = 0; brIdx < pipeBranchesCellIds.size(); brIdx++ )
{
const std::vector<RigWellResultPoint>& branchResPoints = pipeBranchesCellIds[brIdx];
const std::vector<cvf::Vec3d>& branchClPoints = pipeBranchesCLCoords[brIdx];
std::vector<RigWellResultPoint> branchResPointsWithCellCenters;
std::vector<cvf::Vec3d> branchClPointsWithCellCenters;
for ( size_t cIdx = 0; cIdx < branchResPoints.size(); cIdx++ )
{
branchResPointsWithCellCenters.push_back( branchResPoints[cIdx] );
branchClPointsWithCellCenters.push_back( branchClPoints[cIdx] );
if ( branchResPoints[cIdx].isCell() )
{
const RigCell& cell = eclipseCaseData->cellFromWellResultCell( branchResPoints[cIdx] );
cvf::Vec3d center = cell.center();
branchClPointsWithCellCenters.push_back( center );
branchResPointsWithCellCenters.push_back( branchResPoints[cIdx] );
}
}
branchClPointsWithCellCenters.push_back( branchClPoints[branchResPoints.size()] );
pipeBranchesCellIds[brIdx] = branchResPointsWithCellCenters;
pipeBranchesCLCoords[brIdx] = branchClPointsWithCellCenters;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigSimulationWellCenterLineCalculator::hasAnyValidDataCells( const RigWellResultBranch& branch )
{
for ( const auto& branchResultPoint : branch.branchResultPoints() )
{
if ( branchResultPoint.isValid() ) return true;
}
return false;
}
//--------------------------------------------------------------------------------------------------
/// All branches are completed using the point 0.5 past the center of
/// last cell.
//--------------------------------------------------------------------------------------------------
void RigSimulationWellCenterLineCalculator::finishPipeCenterLine( std::vector<std::vector<cvf::Vec3d>>& pipeBranchesCLCoords,
const cvf::Vec3d& lastCellCenter )
{
CVF_ASSERT( pipeBranchesCLCoords.size() );
CVF_ASSERT( pipeBranchesCLCoords.back().size() );
cvf::Vec3d entryPointLastCell = pipeBranchesCLCoords.back().back();
pipeBranchesCLCoords.back().push_back( entryPointLastCell + 1.5 * ( lastCellCenter - entryPointLastCell ) );
}
Reference in New Issue View Git Blame Copy Permalink