mirror of
https://github.com/OPM/ResInsight.git
synced 2025-01-24 15:26:48 -06:00
455 lines
20 KiB
C++
455 lines
20 KiB
C++
/////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (C) 2018- 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 "RicCreateWellTargetsPickEventHandler.h"
|
|
|
|
#include "RiaGuiApplication.h"
|
|
#include "RiaOffshoreSphericalCoords.h"
|
|
|
|
#include "RigFemPart.h"
|
|
#include "RigFemPartCollection.h"
|
|
#include "RigFemPartGrid.h"
|
|
#include "RigHexIntersectionTools.h"
|
|
#include "RigMainGrid.h"
|
|
#include "RigWellPath.h"
|
|
|
|
#include "Rim3dView.h"
|
|
#include "RimEclipseView.h"
|
|
#include "RimGeoMechView.h"
|
|
#include "RimModeledWellPath.h"
|
|
#include "RimWellPath.h"
|
|
#include "RimWellPathGeometryDef.h"
|
|
#include "RimWellPathLateralGeometryDef.h"
|
|
#include "RimWellPathTarget.h"
|
|
|
|
#include "RiuViewerCommands.h"
|
|
|
|
#include "RivFemPartGeometryGenerator.h"
|
|
#include "RivFemPickSourceInfo.h"
|
|
#include "RivSourceInfo.h"
|
|
#include "RivWellPathSourceInfo.h"
|
|
|
|
#include "cafDisplayCoordTransform.h"
|
|
#include "cafSelectionManager.h"
|
|
|
|
#include "cvfStructGridGeometryGenerator.h"
|
|
|
|
#include <QDebug>
|
|
|
|
#include <vector>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RicCreateWellTargetsPickEventHandler::RicCreateWellTargetsPickEventHandler(
|
|
gsl::not_null<RimWellPathGeometryDefInterface*> wellGeometryDef )
|
|
: m_geometryToAddTargetsTo( wellGeometryDef )
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
RicCreateWellTargetsPickEventHandler::~RicCreateWellTargetsPickEventHandler()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicCreateWellTargetsPickEventHandler::registerAsPickEventHandler()
|
|
{
|
|
RiaGuiApplication::instance()->setOverrideCursor( Qt::CrossCursor );
|
|
Ric3dViewPickEventHandler::registerAsPickEventHandler();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicCreateWellTargetsPickEventHandler::notifyUnregistered()
|
|
{
|
|
RiaGuiApplication::instance()->restoreOverrideCursor();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicCreateWellTargetsPickEventHandler::handle3dPickEvent( const Ric3dPickEvent& eventObject )
|
|
{
|
|
if ( m_geometryToAddTargetsTo )
|
|
{
|
|
Rim3dView* rimView = eventObject.m_view;
|
|
cvf::Vec3d targetPointInDomain = cvf::Vec3d::ZERO;
|
|
|
|
// If clicked on an other well path, snap target point to well path center line
|
|
auto firstPickItem = eventObject.m_pickItemInfos.front();
|
|
|
|
auto intersectionPointInDomain =
|
|
rimView->displayCoordTransform()->transformToDomainCoord( firstPickItem.globalPickedPoint() );
|
|
|
|
double azimuth = std::numeric_limits<double>::infinity();
|
|
double inclination = std::numeric_limits<double>::infinity();
|
|
|
|
auto wellPathSourceInfo = dynamic_cast<const RivWellPathSourceInfo*>( firstPickItem.sourceInfo() );
|
|
|
|
if ( isValidWellPathSourceObject( wellPathSourceInfo ) )
|
|
{
|
|
calculateWellPathGeometryAtPickPoint( firstPickItem,
|
|
wellPathSourceInfo,
|
|
intersectionPointInDomain,
|
|
&targetPointInDomain,
|
|
&azimuth,
|
|
&inclination );
|
|
}
|
|
else if ( isGridSourceObject( firstPickItem.sourceInfo() ) )
|
|
{
|
|
targetPointInDomain = calculateGridPickPoint( rimView, firstPickItem, intersectionPointInDomain );
|
|
}
|
|
else
|
|
{
|
|
targetPointInDomain = intersectionPointInDomain;
|
|
}
|
|
|
|
if ( auto wellPathGeometryDef = dynamic_cast<RimWellPathGeometryDef*>( m_geometryToAddTargetsTo.p() );
|
|
wellPathGeometryDef )
|
|
{
|
|
addNewTargetToModeledWellPath( firstPickItem,
|
|
wellPathGeometryDef,
|
|
intersectionPointInDomain,
|
|
targetPointInDomain,
|
|
azimuth,
|
|
inclination );
|
|
}
|
|
else if ( auto wellPathLateralGeometryDef =
|
|
dynamic_cast<RimWellPathLateralGeometryDef*>( m_geometryToAddTargetsTo.p() );
|
|
wellPathLateralGeometryDef )
|
|
{
|
|
addNewTargetToModeledWellPathLateral( firstPickItem,
|
|
wellPathLateralGeometryDef,
|
|
intersectionPointInDomain,
|
|
targetPointInDomain,
|
|
azimuth,
|
|
inclination );
|
|
}
|
|
|
|
return true; // Todo: See if we really should eat the event instead
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicCreateWellTargetsPickEventHandler::calculateAzimuthAndInclinationAtMd( double measuredDepth,
|
|
gsl::not_null<const RigWellPath*> wellPathGeometry,
|
|
double* azimuth,
|
|
double* inclination ) const
|
|
{
|
|
int mdIndex = -1;
|
|
auto mdList = wellPathGeometry->measuredDepths();
|
|
|
|
for ( int i = 0; i < (int)mdList.size(); i++ )
|
|
{
|
|
if ( mdList[i] > measuredDepth )
|
|
{
|
|
mdIndex = i - 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
auto ptList = wellPathGeometry->wellPathPoints();
|
|
if ( mdIndex > 0 && mdIndex < (int)ptList.size() - 2 )
|
|
{
|
|
auto v1 = cvf::Vec3d( ptList[mdIndex - 1] );
|
|
auto v2 = cvf::Vec3d( ptList[mdIndex] );
|
|
auto v3 = cvf::Vec3d( ptList[mdIndex + 1] );
|
|
auto v4 = cvf::Vec3d( ptList[mdIndex + 2] );
|
|
|
|
auto v21 = v2 - v1;
|
|
auto v32 = v3 - v2;
|
|
auto v43 = v4 - v3;
|
|
|
|
v21.normalize();
|
|
v32.normalize();
|
|
v43.normalize();
|
|
|
|
auto v13mean = ( v21 + v32 ) / 2;
|
|
auto v24mean = ( v32 + v43 ) / 2;
|
|
|
|
double weight = ( measuredDepth - mdList[mdIndex] ) / ( mdList[mdIndex + 1] - mdList[mdIndex] );
|
|
auto vTan = v13mean * weight + v24mean * ( 1 - weight );
|
|
|
|
RiaOffshoreSphericalCoords coords( vTan );
|
|
*azimuth = coords.azi();
|
|
*inclination = coords.inc();
|
|
return true;
|
|
}
|
|
|
|
*azimuth = 0.0;
|
|
*inclination = 0.0;
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicCreateWellTargetsPickEventHandler::calculateWellPathGeometryAtPickPoint(
|
|
const RiuPickItemInfo& pickItem,
|
|
gsl::not_null<const RivWellPathSourceInfo*> wellPathSourceInfo,
|
|
const cvf::Vec3d& intersectionPointInDomain,
|
|
gsl::not_null<cvf::Vec3d*> targetPointInDomain,
|
|
gsl::not_null<double*> azimuth,
|
|
gsl::not_null<double*> inclination ) const
|
|
{
|
|
*targetPointInDomain = wellPathSourceInfo->closestPointOnCenterLine( pickItem.faceIdx(), intersectionPointInDomain );
|
|
|
|
bool doSetAzimuthAndInclination = false;
|
|
|
|
auto wellPathGeometry = wellPathSourceInfo->wellPath()->wellPathGeometry();
|
|
if ( wellPathGeometry )
|
|
{
|
|
double md = wellPathSourceInfo->measuredDepth( pickItem.faceIdx(), intersectionPointInDomain );
|
|
|
|
doSetAzimuthAndInclination = calculateAzimuthAndInclinationAtMd( md, wellPathGeometry, azimuth, inclination );
|
|
double rkbDiff = wellPathGeometry->rkbDiff();
|
|
auto wellPathGeometryDef = dynamic_cast<RimWellPathGeometryDef*>( m_geometryToAddTargetsTo.p() );
|
|
if ( wellPathGeometryDef && wellPathGeometryDef->airGap() == 0.0 &&
|
|
rkbDiff != std::numeric_limits<double>::infinity() )
|
|
{
|
|
wellPathGeometryDef->setAirGap( rkbDiff );
|
|
}
|
|
}
|
|
return doSetAzimuthAndInclination;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RicCreateWellTargetsPickEventHandler::calculateGridPickPoint( gsl::not_null<const Rim3dView*> rimView,
|
|
const RiuPickItemInfo& pickItem,
|
|
const cvf::Vec3d& intersectionPointInDomain ) const
|
|
{
|
|
auto targetPointInDomain = intersectionPointInDomain;
|
|
|
|
cvf::Vec3d domainRayOrigin = rimView->displayCoordTransform()->transformToDomainCoord( pickItem.globalRayOrigin() );
|
|
cvf::Vec3d domainRayEnd = targetPointInDomain + ( targetPointInDomain - domainRayOrigin );
|
|
|
|
cvf::Vec3d hexElementIntersection = findHexElementIntersection( rimView, pickItem, domainRayOrigin, domainRayEnd );
|
|
CVF_TIGHT_ASSERT( !hexElementIntersection.isUndefined() );
|
|
if ( !hexElementIntersection.isUndefined() )
|
|
{
|
|
targetPointInDomain = hexElementIntersection;
|
|
}
|
|
return targetPointInDomain;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicCreateWellTargetsPickEventHandler::addNewTargetToModeledWellPath( const RiuPickItemInfo& pickItem,
|
|
gsl::not_null<RimWellPathGeometryDef*> wellPathGeometryDef,
|
|
const cvf::Vec3d& intersectionPointInDomain,
|
|
const cvf::Vec3d& targetPointInDomain,
|
|
double azimuth,
|
|
double inclination )
|
|
{
|
|
if ( !m_geometryToAddTargetsTo->firstActiveTarget() )
|
|
{
|
|
wellPathGeometryDef->setReferencePointXyz( targetPointInDomain );
|
|
|
|
auto wellPathSourceInfo = dynamic_cast<const RivWellPathSourceInfo*>( pickItem.sourceInfo() );
|
|
if ( wellPathSourceInfo )
|
|
{
|
|
double mdAtFirstTarget = wellPathSourceInfo->measuredDepth( pickItem.faceIdx(), intersectionPointInDomain );
|
|
|
|
RimModeledWellPath* modeledWellPath = dynamic_cast<RimModeledWellPath*>( wellPathSourceInfo->wellPath() );
|
|
if ( modeledWellPath )
|
|
{
|
|
mdAtFirstTarget += modeledWellPath->geometryDefinition()->mdAtFirstTarget();
|
|
}
|
|
|
|
wellPathGeometryDef->setMdAtFirstTarget( mdAtFirstTarget );
|
|
}
|
|
}
|
|
|
|
cvf::Vec3d referencePoint = wellPathGeometryDef->anchorPointXyz();
|
|
cvf::Vec3d relativeTargetPoint = targetPointInDomain - referencePoint;
|
|
|
|
RimWellPathTarget* newTarget = new RimWellPathTarget;
|
|
|
|
bool doSetAzimuthAndInclination = azimuth != std::numeric_limits<double>::infinity() &&
|
|
inclination != std::numeric_limits<double>::infinity();
|
|
if ( doSetAzimuthAndInclination )
|
|
{
|
|
newTarget->setAsPointXYZAndTangentTarget( relativeTargetPoint, azimuth, inclination );
|
|
}
|
|
else
|
|
{
|
|
newTarget->setAsPointTargetXYD(
|
|
cvf::Vec3d( relativeTargetPoint.x(), relativeTargetPoint.y(), -relativeTargetPoint.z() ) );
|
|
}
|
|
|
|
m_geometryToAddTargetsTo->insertTarget( nullptr, newTarget );
|
|
m_geometryToAddTargetsTo->updateConnectedEditors();
|
|
m_geometryToAddTargetsTo->updateWellPathVisualization( false );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void RicCreateWellTargetsPickEventHandler::addNewTargetToModeledWellPathLateral(
|
|
const RiuPickItemInfo& pickItem,
|
|
gsl::not_null<RimWellPathLateralGeometryDef*> wellPathLateralGeometryDef,
|
|
const cvf::Vec3d& intersectionPointInDomain,
|
|
const cvf::Vec3d& targetPointInDomain,
|
|
double azimuth,
|
|
double inclination )
|
|
{
|
|
auto wellPathSourceInfo = dynamic_cast<const RivWellPathSourceInfo*>( pickItem.sourceInfo() );
|
|
if ( wellPathSourceInfo )
|
|
{
|
|
double mdAtConnection = wellPathSourceInfo->measuredDepth( pickItem.faceIdx(), intersectionPointInDomain );
|
|
|
|
wellPathLateralGeometryDef->setParentGeometry( wellPathSourceInfo->wellPath()->wellPathGeometry() );
|
|
wellPathLateralGeometryDef->setMdAtConnection( mdAtConnection );
|
|
}
|
|
cvf::Vec3d referencePoint = wellPathLateralGeometryDef->anchorPointXyz();
|
|
cvf::Vec3d relativeTargetPoint = targetPointInDomain - referencePoint;
|
|
|
|
RimWellPathTarget* newTarget = new RimWellPathTarget;
|
|
|
|
bool doSetAzimuthAndInclination = azimuth != std::numeric_limits<double>::infinity() &&
|
|
inclination != std::numeric_limits<double>::infinity();
|
|
if ( doSetAzimuthAndInclination )
|
|
{
|
|
newTarget->setAsPointXYZAndTangentTarget( cvf::Vec3d( relativeTargetPoint.x(),
|
|
relativeTargetPoint.y(),
|
|
relativeTargetPoint.z() ),
|
|
azimuth,
|
|
inclination );
|
|
}
|
|
else
|
|
{
|
|
newTarget->setAsPointTargetXYD(
|
|
cvf::Vec3d( relativeTargetPoint.x(), relativeTargetPoint.y(), -relativeTargetPoint.z() ) );
|
|
}
|
|
|
|
m_geometryToAddTargetsTo->insertTarget( nullptr, newTarget );
|
|
m_geometryToAddTargetsTo->updateConnectedEditors();
|
|
m_geometryToAddTargetsTo->updateWellPathVisualization( false );
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicCreateWellTargetsPickEventHandler::isGridSourceObject( const cvf::Object* object )
|
|
{
|
|
auto sourceInfo = dynamic_cast<const RivSourceInfo*>( object );
|
|
auto femSourceInfo = dynamic_cast<const RivFemPickSourceInfo*>( object );
|
|
return sourceInfo || femSourceInfo;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool RicCreateWellTargetsPickEventHandler::isValidWellPathSourceObject( const RivWellPathSourceInfo* wellPathSourceInfo )
|
|
{
|
|
return wellPathSourceInfo && wellPathSourceInfo->wellPath() && wellPathSourceInfo->wellPath()->wellPathGeometry();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d RicCreateWellTargetsPickEventHandler::findHexElementIntersection( gsl::not_null<const Rim3dView*> view,
|
|
const RiuPickItemInfo& pickItem,
|
|
const cvf::Vec3d& domainRayOrigin,
|
|
const cvf::Vec3d& domainRayEnd )
|
|
{
|
|
auto sourceInfo = dynamic_cast<const RivSourceInfo*>( pickItem.sourceInfo() );
|
|
auto femSourceInfo = dynamic_cast<const RivFemPickSourceInfo*>( pickItem.sourceInfo() );
|
|
|
|
size_t cellIndex = cvf::UNDEFINED_SIZE_T;
|
|
std::array<cvf::Vec3d, 8> cornerVertices;
|
|
if ( sourceInfo )
|
|
{
|
|
size_t gridIndex = sourceInfo->gridIndex();
|
|
if ( sourceInfo->hasCellFaceMapping() )
|
|
{
|
|
cellIndex = sourceInfo->m_cellFaceFromTriangleMapper->cellIndex( pickItem.faceIdx() );
|
|
|
|
const RimEclipseView* eclipseView = dynamic_cast<const RimEclipseView*>( view.get() );
|
|
if ( eclipseView && eclipseView->mainGrid() )
|
|
{
|
|
RigGridBase* hitGrid = eclipseView->mainGrid()->gridByIndex( gridIndex );
|
|
hitGrid->cellCornerVertices( cellIndex, cornerVertices.data() );
|
|
}
|
|
}
|
|
}
|
|
else if ( femSourceInfo )
|
|
{
|
|
size_t femPartIndex = femSourceInfo->femPartIndex();
|
|
if ( femSourceInfo->triangleToElmMapper() )
|
|
{
|
|
size_t elementIndex = femSourceInfo->triangleToElmMapper()->elementIndex( pickItem.faceIdx() );
|
|
|
|
const RimGeoMechView* geoMechView = dynamic_cast<const RimGeoMechView*>( view.get() );
|
|
if ( geoMechView && geoMechView->femParts() )
|
|
{
|
|
const RigFemPart* femPart = geoMechView->femParts()->part( femPartIndex );
|
|
RigElementType elType = femPart->elementType( elementIndex );
|
|
|
|
if ( elType == HEX8 || elType == HEX8P )
|
|
{
|
|
cellIndex = elementIndex;
|
|
const RigFemPartGrid* femGrid = femPart->getOrCreateStructGrid();
|
|
femGrid->cellCornerVertices( cellIndex, cornerVertices.data() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( cellIndex )
|
|
{
|
|
std::vector<HexIntersectionInfo> intersectionInfo;
|
|
RigHexIntersectionTools::lineHexCellIntersection( domainRayOrigin,
|
|
domainRayEnd,
|
|
cornerVertices.data(),
|
|
cellIndex,
|
|
&intersectionInfo );
|
|
if ( !intersectionInfo.empty() )
|
|
{
|
|
// Sort intersection on distance to ray origin
|
|
CVF_ASSERT( intersectionInfo.size() > 1 );
|
|
std::sort( intersectionInfo.begin(),
|
|
intersectionInfo.end(),
|
|
[&domainRayOrigin]( const HexIntersectionInfo& lhs, const HexIntersectionInfo& rhs ) {
|
|
return ( lhs.m_intersectionPoint - domainRayOrigin ).lengthSquared() <
|
|
( rhs.m_intersectionPoint - domainRayOrigin ).lengthSquared();
|
|
} );
|
|
const double eps = 1.0e-2;
|
|
cvf::Vec3d intersectionRay = intersectionInfo.back().m_intersectionPoint -
|
|
intersectionInfo.front().m_intersectionPoint;
|
|
cvf::Vec3d newPoint = intersectionInfo.front().m_intersectionPoint + intersectionRay * eps;
|
|
CVF_ASSERT( RigHexIntersectionTools::isPointInCell( newPoint, cornerVertices.data() ) );
|
|
return newPoint;
|
|
}
|
|
}
|
|
return cvf::Vec3d::UNDEFINED;
|
|
}
|