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

#933 Fixed closest result for pr element face-node result when picking on elements. Also fixed the result plot in the same respect.

Browse Source
This commit is contained in:
Jacob Støren
2016-10-25 13:42:40 +02:00
parent c418650546
commit a9b2451cdd
10 changed files with 189 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.cpp
View File

@@ -1368,3 +1368,91 @@ int RigFemPartResultsCollection::partCount() const
return m_femParts->partCount();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigFemClosestResultIndexCalculator::RigFemClosestResultIndexCalculator(RigFemPart* femPart,
RigFemResultPosEnum resultPosition,
int elementIndex,
int m_face,
const cvf::Vec3d& m_intersectionPoint)
{
m_resultIndexToClosestResult = -1;
m_closestNodeId = -1;
if ( resultPosition != RIG_ELEMENT_NODAL_FACE )
{
RigElementType elmType = femPart->elementType(elementIndex);
const int* elmentConn = femPart->connectivities(elementIndex);
int elmNodeCount = RigFemTypes::elmentNodeCount(elmType);
// Find the closest node
int closestLocalNode = -1;
float minDist = std::numeric_limits<float>::infinity();
for ( int lNodeIdx = 0; lNodeIdx < elmNodeCount; ++lNodeIdx )
{
int nodeIdx = elmentConn[lNodeIdx];
cvf::Vec3f nodePos = femPart->nodes().coordinates[nodeIdx];
float dist = (nodePos - cvf::Vec3f(m_intersectionPoint)).lengthSquared();
if ( dist < minDist )
{
closestLocalNode = lNodeIdx;
minDist = dist;
}
}
if ( closestLocalNode >= 0 )
{
float scalarValue = std::numeric_limits<float>::infinity();
int nodeIdx = elmentConn[closestLocalNode];
if ( resultPosition == RIG_NODAL )
{
m_resultIndexToClosestResult = nodeIdx;
}
else
{
m_resultIndexToClosestResult = static_cast<int>(femPart->elementNodeResultIdx(elementIndex, closestLocalNode));
}
m_closestNodeId = femPart->nodes().nodeIds[nodeIdx];
}
}
else if ( m_face != -1 )
{
int elmNodFaceResIdx = -1;
int closestNodeIdx = -1;
{
int closestLocFaceNode = -1;
{
RigElementType elmType = femPart->elementType(elementIndex);
int faceCount = RigFemTypes::elmentFaceCount(elmType);
const int* elmNodeIndices = femPart->connectivities(elementIndex);
int faceNodeCount = 0;
const int* localElmNodeIndicesForFace = RigFemTypes::localElmNodeIndicesForFace(elmType, m_face, &faceNodeCount);
float minDist = std::numeric_limits<float>::infinity();
for ( int faceNodIdx = 0; faceNodIdx < faceNodeCount; ++faceNodIdx )
{
int nodeIdx = elmNodeIndices[localElmNodeIndicesForFace[faceNodIdx]];
cvf::Vec3f nodePos = femPart->nodes().coordinates[nodeIdx];
float dist = (nodePos - cvf::Vec3f(m_intersectionPoint)).lengthSquared();
if ( dist < minDist )
{
closestLocFaceNode = faceNodIdx;
closestNodeIdx = nodeIdx;
minDist = dist;
}
}
}
int elmNodFaceResIdxElmStart = elementIndex * 24; // HACK should get from part
int elmNodFaceResIdxFaceStart = elmNodFaceResIdxElmStart + 4*m_face;
if ( closestLocFaceNode >= 0 ) elmNodFaceResIdx = elmNodFaceResIdxFaceStart + closestLocFaceNode;
}
m_resultIndexToClosestResult = elmNodFaceResIdx;
m_closestNodeId = femPart->nodes().nodeIds[closestNodeIdx];
}
}

19
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPartResultsCollection.h
View File

@@ -124,3 +124,22 @@ public:
private:
std::array<float, 3> incAziR;
};
class RigFemPart;
class RigFemClosestResultIndexCalculator
{
public:
RigFemClosestResultIndexCalculator(RigFemPart* femPart,
RigFemResultPosEnum resultPosition,
int elementIndex,
int m_face,
const cvf::Vec3d& m_intersectionPoint);
int resultIndexToClosestResult() { return m_resultIndexToClosestResult; }
int closestNodeId() { return m_closestNodeId; }
private:
int m_resultIndexToClosestResult;
int m_closestNodeId;
};

58
ApplicationCode/GeoMech/GeoMechDataModel/RigFemTimeHistoryResultAccessor.cpp
View File

@@ -31,12 +31,17 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigFemTimeHistoryResultAccessor::RigFemTimeHistoryResultAccessor(RigGeoMechCaseData* geomData, RigFemResultAddress femResultAddress,
size_t gridIndex, size_t cellIndex, const cvf::Vec3d& intersectionPoint)
RigFemTimeHistoryResultAccessor::RigFemTimeHistoryResultAccessor(RigGeoMechCaseData* geomData,
RigFemResultAddress femResultAddress,
size_t gridIndex,
size_t cellIndex,
int face,
const cvf::Vec3d& intersectionPoint)
: m_geoMechCaseData(geomData),
m_femResultAddress(femResultAddress),
m_gridIndex(gridIndex),
m_cellIndex(cellIndex),
m_face(face),
m_intersectionPoint(intersectionPoint)
{
computeTimeHistoryData();
@@ -66,7 +71,7 @@ QString RigFemTimeHistoryResultAccessor::topologyText() const
k++;
cvf::Vec3d domainCoord = m_intersectionPoint;
text += QString(", ijk[%1, %2, %3]").arg(i).arg(j).arg(k);
text += QString(", ijk[%1, %2, %3] ").arg(i).arg(j).arg(k);
QString formattedText;
formattedText.sprintf("Intersection point : [E: %.2f, N: %.2f, Depth: %.2f]", domainCoord.x(), domainCoord.y(), -domainCoord.z());
@@ -93,46 +98,15 @@ void RigFemTimeHistoryResultAccessor::computeTimeHistoryData()
{
m_timeHistoryValues.clear();
size_t scalarResultIndex = cvf::UNDEFINED_SIZE_T;
RigFemClosestResultIndexCalculator closestCalc(m_geoMechCaseData->femParts()->part(m_gridIndex),
m_femResultAddress.resultPosType,
m_cellIndex,
m_face,
m_intersectionPoint );
int scalarResultIndex = closestCalc.resultIndexToClosestResult();
// Compute scalar result index from geometry
{
RigFemPart* femPart = m_geoMechCaseData->femParts()->part(m_gridIndex);
RigElementType elmType = femPart->elementType(m_cellIndex);
const int* elmentConn = femPart->connectivities(m_cellIndex);
int elmNodeCount = RigFemTypes::elmentNodeCount(elmType);
// Find the closest node
int closestLocalNode = -1;
float minDist = std::numeric_limits<float>::infinity();
for (int lNodeIdx = 0; lNodeIdx < elmNodeCount; ++lNodeIdx)
{
int nodeIdx = elmentConn[lNodeIdx];
cvf::Vec3f nodePos = femPart->nodes().coordinates[nodeIdx];
float dist = (nodePos - cvf::Vec3f(m_intersectionPoint)).lengthSquared();
if (dist < minDist)
{
closestLocalNode = lNodeIdx;
minDist = dist;
}
}
// Create a text showing the results from the closest node
if (closestLocalNode >= 0)
{
int nodeIdx = elmentConn[closestLocalNode];
if (m_femResultAddress.resultPosType == RIG_NODAL)
{
scalarResultIndex = static_cast<size_t>(nodeIdx);
}
else
{
scalarResultIndex = femPart->elementNodeResultIdx(static_cast<int>(m_cellIndex), closestLocalNode);
}
}
}
if (scalarResultIndex == cvf::UNDEFINED_SIZE_T) return;
if (scalarResultIndex < 0) return;
RigFemPartResultsCollection* femPartResultsColl = m_geoMechCaseData->femPartResults();
for (int frameIdx = 0; frameIdx < femPartResultsColl->frameCount(); frameIdx++)

9
ApplicationCode/GeoMech/GeoMechDataModel/RigFemTimeHistoryResultAccessor.h
View File

@@ -30,8 +30,12 @@ class RigGeoMechCaseData;
class RigFemTimeHistoryResultAccessor
{
public:
RigFemTimeHistoryResultAccessor(RigGeoMechCaseData* geomData, RigFemResultAddress femResultAddress,
size_t gridIndex, size_t cellIndex, const cvf::Vec3d& intersectionPoint);
RigFemTimeHistoryResultAccessor(RigGeoMechCaseData* geomData,
RigFemResultAddress femResultAddress,
size_t gridIndex,
size_t cellIndex,
int face,
const cvf::Vec3d& intersectionPoint);
QString topologyText() const;
std::vector<double> timeHistoryValues() const;
@@ -46,6 +50,7 @@ private:
size_t m_gridIndex;
size_t m_cellIndex;
size_t m_scalarResultIndex;
int m_face;
cvf::Vec3d m_intersectionPoint;

57
ApplicationCode/UserInterface/RiuFemResultTextBuilder.cpp
View File

@@ -59,7 +59,7 @@ void RiuFemResultTextBuilder::setIntersectionPoint(cvf::Vec3d intersectionPoint)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuFemResultTextBuilder::setFace(cvf::StructGridInterface::FaceType face)
void RiuFemResultTextBuilder::setFace(int face)
{
m_face = face;
}
@@ -328,50 +328,37 @@ QString RiuFemResultTextBuilder::closestNodeResultText(RimGeoMechResultDefinitio
RigGeoMechCaseData* geomData = m_reservoirView->geoMechCase()->geoMechData();
const std::vector<float>& scalarResults = geomData->femPartResults()->resultValues(resultColors->resultAddress(), m_gridIndex, m_timeStepIndex);
if (scalarResults.size())
{
RigFemPart* femPart = geomData->femParts()->part(m_gridIndex);
RigElementType elmType = femPart->elementType(m_cellIndex);
const int* elmentConn = femPart->connectivities(m_cellIndex);
int elmNodeCount = RigFemTypes::elmentNodeCount(elmType);
RigFemResultPosEnum activeResultPosition = resultColors->resultPositionType();
// Find the closest node
int closestLocalNode = -1;
float minDist = std::numeric_limits<float>::infinity();
for (int lNodeIdx = 0; lNodeIdx < elmNodeCount; ++lNodeIdx)
RigFemClosestResultIndexCalculator closestIndexCalc(femPart,
activeResultPosition,
m_cellIndex,
m_face,
m_intersectionPoint);
int resultIndex = closestIndexCalc.resultIndexToClosestResult();
int closestNodeId = closestIndexCalc.closestNodeId();
float scalarValue = (resultIndex >= 0) ? scalarResults[resultIndex]: std::numeric_limits<float>::infinity();
if (activeResultPosition != RIG_ELEMENT_NODAL_FACE)
{
int nodeIdx = elmentConn[lNodeIdx];
cvf::Vec3f nodePos = femPart->nodes().coordinates[nodeIdx];
float dist = (nodePos - cvf::Vec3f(m_intersectionPoint)).lengthSquared();
if (dist < minDist)
{
closestLocalNode = lNodeIdx;
minDist = dist;
}
text.append(QString("Closest result: N[%1], %2\n").arg(closestNodeId)
.arg(scalarValue));
}
// Create a text showing the results from the closest node
if (closestLocalNode >= 0)
else if ( m_face != -1 )
{
float scalarValue = std::numeric_limits<float>::infinity();
int nodeIdx = elmentConn[closestLocalNode];
if (resultColors->resultPositionType() == RIG_NODAL)
{
scalarValue = scalarResults[nodeIdx];
}
else
{
size_t resIdx = femPart->elementNodeResultIdx(m_cellIndex, closestLocalNode);
scalarValue = scalarResults[resIdx];
}
text.append(QString("Closest result: N[%1], %2\n").arg(femPart->nodes().nodeIds[nodeIdx]).arg(scalarValue));
text.append(QString("Closest result: N[%1], on face: %2, %3\n").arg(closestNodeId)
.arg(caf::AppEnum<cvf::StructGridInterface::FaceType>::textFromIndex(m_face))
.arg(scalarValue));
}
}
}
return text;
}

4
ApplicationCode/UserInterface/RiuFemResultTextBuilder.h
View File

@@ -42,7 +42,7 @@ class RiuFemResultTextBuilder
{
public:
RiuFemResultTextBuilder(RimGeoMechView* reservoirView, int gridIndex, int cellIndex, int timeStepIndex);
void setFace(cvf::StructGridInterface::FaceType face);
void setFace(int face);
void setIntersectionPoint(cvf::Vec3d intersectionPoint);
QString mainResultText();
@@ -66,7 +66,7 @@ private:
int m_cellIndex;
int m_timeStepIndex;
cvf::StructGridInterface::FaceType m_face;
int m_face;
cvf::Vec3d m_intersectionPoint;
};

20
ApplicationCode/UserInterface/RiuSelectionChangedHandler.cpp
View File

@@ -143,8 +143,12 @@ void RiuSelectionChangedHandler::addCurveFromSelectionItem(const RiuGeoMechSelec
geoMechView->geoMechCase() &&
geoMechView->geoMechCase()->geoMechData())
{
RigFemTimeHistoryResultAccessor timeHistResultAccessor(geoMechView->geoMechCase()->geoMechData(), geoMechView->cellResultResultDefinition()->resultAddress(),
geomSelectionItem->m_gridIndex, geomSelectionItem->m_cellIndex, geomSelectionItem->m_localIntersectionPoint);
RigFemTimeHistoryResultAccessor timeHistResultAccessor(geoMechView->geoMechCase()->geoMechData(),
geoMechView->cellResultResultDefinition()->resultAddress(),
geomSelectionItem->m_gridIndex,
geomSelectionItem->m_cellIndex,
geomSelectionItem->m_elementFace,
geomSelectionItem->m_localIntersectionPoint);
QString curveName;
curveName.append(geoMechView->geoMechCase()->caseUserDescription() + ", ");
@@ -152,7 +156,15 @@ void RiuSelectionChangedHandler::addCurveFromSelectionItem(const RiuGeoMechSelec
caf::AppEnum<RigFemResultPosEnum> resPosAppEnum = geoMechView->cellResultResultDefinition()->resultPositionType();
curveName.append(resPosAppEnum.uiText() + ", ");
curveName.append(geoMechView->cellResultResultDefinition()->resultFieldUiName()+ ", ") ;
curveName.append(geoMechView->cellResultResultDefinition()->resultComponentUiName() + ":\n");
curveName.append(geoMechView->cellResultResultDefinition()->resultComponentUiName() + " ");
if ( resPosAppEnum == RIG_ELEMENT_NODAL_FACE && geomSelectionItem->m_elementFace >= 0 )
{
curveName.append(", " + caf::AppEnum<cvf::StructGridInterface::FaceType>::textFromIndex(geomSelectionItem->m_elementFace));
}
curveName.append(":\n");
curveName.append(timeHistResultAccessor.topologyText());
std::vector<double> timeHistoryValues = timeHistResultAccessor.timeHistoryValues();
@@ -245,7 +257,7 @@ void RiuSelectionChangedHandler::updateResultInfo(const RiuSelectionItem* itemAd
RimGeoMechView* geomView = geomSelectionItem->m_view.p();
RiuFemResultTextBuilder textBuilder(geomView, (int)geomSelectionItem->m_gridIndex, (int)geomSelectionItem->m_cellIndex, geomView->currentTimeStep());
textBuilder.setIntersectionPoint(geomSelectionItem->m_localIntersectionPoint);
textBuilder.setFace(geomSelectionItem->m_elementFace);
resultInfo = textBuilder.mainResultText();
pickInfo = textBuilder.topologyText(", ");

8
ApplicationCode/UserInterface/RiuSelectionManager.cpp
View File

@@ -129,11 +129,17 @@ RiuEclipseSelectionItem::RiuEclipseSelectionItem(RimEclipseView* view, size_t gr
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuGeoMechSelectionItem::RiuGeoMechSelectionItem(RimGeoMechView* view, size_t gridIndex, size_t cellIndex, cvf::Color3f color, const cvf::Vec3d& localIntersectionPoint)
RiuGeoMechSelectionItem::RiuGeoMechSelectionItem(RimGeoMechView* view,
size_t gridIndex,
size_t cellIndex,
cvf::Color3f color,
int elementFace,
const cvf::Vec3d& localIntersectionPoint)
: m_view(view),
m_gridIndex(gridIndex),
m_cellIndex(cellIndex),
m_color(color),
m_elementFace(elementFace),
m_localIntersectionPoint(localIntersectionPoint)
{
}

8
ApplicationCode/UserInterface/RiuSelectionManager.h
View File

@@ -132,7 +132,12 @@ public:
class RiuGeoMechSelectionItem : public RiuSelectionItem
{
public:
explicit RiuGeoMechSelectionItem(RimGeoMechView* view, size_t gridIndex, size_t cellIndex, cvf::Color3f color, const cvf::Vec3d& localIntersectionPoint);
explicit RiuGeoMechSelectionItem(RimGeoMechView* view,
size_t gridIndex,
size_t cellIndex,
cvf::Color3f color,
int elementFace,
const cvf::Vec3d& localIntersectionPoint);
virtual ~RiuGeoMechSelectionItem() {};
virtual RiuSelectionType type() const
@@ -145,6 +150,7 @@ public:
size_t m_gridIndex;
size_t m_cellIndex;
cvf::Color3f m_color;
int m_elementFace;
cvf::Vec3d m_localIntersectionPoint;
};

6
ApplicationCode/UserInterface/RiuViewerCommands.cpp
View File

@@ -469,6 +469,8 @@ void RiuViewerCommands::handlePickAction(int winPosX, int winPosY, Qt::KeyboardM
size_t cellIndex = cvf::UNDEFINED_SIZE_T;
size_t nncIndex = cvf::UNDEFINED_SIZE_T;
cvf::StructGridInterface::FaceType face = cvf::StructGridInterface::NO_FACE;
int gmFace = -1;
cvf::Vec3d localIntersectionPoint(cvf::Vec3d::ZERO);
// Extract all the above information from the pick
@@ -517,6 +519,8 @@ void RiuViewerCommands::handlePickAction(int winPosX, int winPosY, Qt::KeyboardM
{
gridIndex = femSourceInfo->femPartIndex();
cellIndex = femSourceInfo->triangleToElmMapper()->elementIndex(firstPartTriangleIndex);
gmFace = femSourceInfo->triangleToElmMapper()->elementFace(firstPartTriangleIndex);
}
else if (crossSectionSourceInfo)
{
@@ -578,7 +582,7 @@ void RiuViewerCommands::handlePickAction(int winPosX, int winPosY, Qt::KeyboardM
RimGeoMechView* geomView = dynamic_cast<RimGeoMechView*>(m_reservoirView.p());
if (geomView)
{
selItem = new RiuGeoMechSelectionItem(geomView, gridIndex, cellIndex, curveColor, localIntersectionPoint);
selItem = new RiuGeoMechSelectionItem(geomView, gridIndex, cellIndex, curveColor, gmFace, localIntersectionPoint);
}
}