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

#914 Transformed stress on intersection Box is working

Browse Source
This commit is contained in:
Jacob Støren 2016-10-20 16:09:27 +02:00
parent 159bbbe5e6
commit b4c6277e72
8 changed files with 71 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxGeometryGenerator.cpp
View File

@ -113,6 +113,19 @@ const std::vector<RivIntersectionVertexWeights>& RivIntersectionBoxGeometryGener
return m_triVxToCellCornerWeights;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const cvf::Vec3fArray* RivIntersectionBoxGeometryGenerator::triangleVxes() const
{
CVF_ASSERT(m_triangleVxes->size());
return m_triangleVxes.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
class Box
{

1
ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxGeometryGenerator.h
View File

@ -55,6 +55,7 @@ public:
// Mapping between cells and geometry
const std::vector<size_t>& triangleToCellIndex() const;
const std::vector<RivIntersectionVertexWeights>& triangleVxToCellCornerInterpolationWeights() const;
const cvf::Vec3fArray* triangleVxes() const;
const RimIntersectionBox* intersectionBox() const;

128
ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxPartMgr.cpp
View File

@ -49,6 +49,7 @@
#include "cvfRenderState_FF.h"
#include "cvfRenderStateDepth.h"
#include "cvfRenderStatePoint.h"
#include "RivIntersectionPartMgr.h"
@ -131,7 +132,7 @@ void RivIntersectionBoxPartMgr::updateCellResultColor(size_t timeStepIndex)
cellResultColors);
}
RivIntersectionBoxPartMgr::calculateEclipseTextureCoordinates(m_intersectionBoxFacesTextureCoords.p(),
RivIntersectionPartMgr::calculateEclipseTextureCoordinates(m_intersectionBoxFacesTextureCoords.p(),
m_intersectionBoxGenerator->triangleToCellIndex(),
resultAccessor.p(),
mapper);
@ -159,21 +160,38 @@ void RivIntersectionBoxPartMgr::updateCellResultColor(size_t timeStepIndex)
RigFemResultAddress resVarAddress = cellResultColors->resultAddress();
// Do a "Hack" to show elm nodal and not nodal POR results
if (resVarAddress.resultPosType == RIG_NODAL && resVarAddress.fieldName == "POR-Bar") resVarAddress.resultPosType = RIG_ELEMENT_NODAL;
const std::vector<RivIntersectionVertexWeights> &vertexWeights = m_intersectionBoxGenerator->triangleVxToCellCornerInterpolationWeights();
const std::vector<float>& resultValues = caseData->femPartResults()->resultValues(resVarAddress, 0, (int)timeStepIndex);
bool isElementNodalResult = !(resVarAddress.resultPosType == RIG_NODAL);
RigFemPart* femPart = caseData->femParts()->part(0);
const cvf::ScalarMapper* mapper = cellResultColors->legendConfig()->scalarMapper();
if (!(resVarAddress.resultPosType == RIG_ELEMENT_NODAL_FACE) )
{
// Do a "Hack" to show elm nodal and not nodal POR results
if ( resVarAddress.resultPosType == RIG_NODAL && resVarAddress.fieldName == "POR-Bar" ) resVarAddress.resultPosType = RIG_ELEMENT_NODAL;
RivIntersectionBoxPartMgr::calculateGeoMechTextureCoords(m_intersectionBoxFacesTextureCoords.p(),
vertexWeights,
resultValues,
isElementNodalResult,
femPart,
mapper);
const std::vector<float>& resultValues = caseData->femPartResults()->resultValues(resVarAddress, 0, (int)timeStepIndex);
RigFemPart* femPart = caseData->femParts()->part(0);
bool isElementNodalResult = !(resVarAddress.resultPosType == RIG_NODAL);
RivIntersectionPartMgr::calculateGeoMechTextureCoords(m_intersectionBoxFacesTextureCoords.p(),
vertexWeights,
resultValues,
isElementNodalResult,
femPart,
mapper);
}
else
{
// Special direction sensitive result calculation
const cvf::Vec3fArray* triangelVxes = m_intersectionBoxGenerator->triangleVxes();
RivIntersectionPartMgr::calculateGeoMechTensorXfTextureCoords(m_intersectionBoxFacesTextureCoords.p(),
triangelVxes,
vertexWeights,
caseData,
resVarAddress,
(int)timeStepIndex,
mapper);
}
RivScalarMapperUtils::applyTextureResultsToPart(m_intersectionBoxFaces.p(),
m_intersectionBoxFacesTextureCoords.p(),
@ -185,90 +203,6 @@ void RivIntersectionBoxPartMgr::updateCellResultColor(size_t timeStepIndex)
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivIntersectionBoxPartMgr::calculateGeoMechTextureCoords(cvf::Vec2fArray* textureCoords,
const std::vector<RivIntersectionVertexWeights> &vertexWeights,
const std::vector<float> &resultValues,
bool isElementNodalResult,
const RigFemPart* femPart,
const cvf::ScalarMapper* mapper)
{
textureCoords->resize(vertexWeights.size());
if (resultValues.size() == 0)
{
textureCoords->setAll(cvf::Vec2f(0.0, 1.0f));
}
else
{
cvf::Vec2f* rawPtr = textureCoords->ptr();
int vxCount = static_cast<int>(vertexWeights.size());
#pragma omp parallel for schedule(dynamic)
for (int triangleVxIdx = 0; triangleVxIdx < vxCount; ++triangleVxIdx)
{
float resValue = 0;
int weightCount = vertexWeights[triangleVxIdx].size();
for (int wIdx = 0; wIdx < weightCount; ++wIdx)
{
size_t resIdx = isElementNodalResult ? vertexWeights[triangleVxIdx].vxId(wIdx) :
femPart->nodeIdxFromElementNodeResultIdx(vertexWeights[triangleVxIdx].vxId(wIdx));
resValue += resultValues[resIdx] * vertexWeights[triangleVxIdx].weight(wIdx);
}
if (resValue == HUGE_VAL || resValue != resValue) // a != a is true for NAN's
{
rawPtr[triangleVxIdx][1] = 1.0f;
}
else
{
rawPtr[triangleVxIdx] = mapper->mapToTextureCoord(resValue);
}
}
}
}
//--------------------------------------------------------------------------------------------------
/// Calculates the texture coordinates in a "nearly" one dimensional texture.
/// Undefined values are coded with a y-texture coordinate value of 1.0 instead of the normal 0.5
//--------------------------------------------------------------------------------------------------
void RivIntersectionBoxPartMgr::calculateEclipseTextureCoordinates(cvf::Vec2fArray* textureCoords,
const std::vector<size_t>& triangleToCellIdxMap,
const RigResultAccessor* resultAccessor,
const cvf::ScalarMapper* mapper)
{
if (!resultAccessor) return;
size_t numVertices = triangleToCellIdxMap.size()*3;
textureCoords->resize(numVertices);
cvf::Vec2f* rawPtr = textureCoords->ptr();
int triangleCount = static_cast<int>(triangleToCellIdxMap.size());
#pragma omp parallel for
for (int tIdx = 0; tIdx < triangleCount; tIdx++)
{
double cellScalarValue = resultAccessor->cellScalarGlobIdx(triangleToCellIdxMap[tIdx]);
cvf::Vec2f texCoord = mapper->mapToTextureCoord(cellScalarValue);
if (cellScalarValue == HUGE_VAL || cellScalarValue != cellScalarValue) // a != a is true for NAN's
{
texCoord[1] = 1.0f;
}
size_t j;
for (j = 0; j < 3; j++)
{
rawPtr[tIdx*3 + j] = texCoord;
}
}
}
const int priCrossSectionGeo = 1;
const int priNncGeo = 2;
const int priMesh = 3;

12
ApplicationCode/ModelVisualization/Intersections/RivIntersectionBoxPartMgr.h
View File

@ -57,18 +57,6 @@ private:
void updatePartEffect();
void generatePartGeometry();
static void calculateEclipseTextureCoordinates(cvf::Vec2fArray* textureCoords,
const std::vector<size_t>& triangleToCellIdxMap,
const RigResultAccessor* resultAccessor,
const cvf::ScalarMapper* mapper);
static void calculateGeoMechTextureCoords(cvf::Vec2fArray* textureCoords,
const std::vector<RivIntersectionVertexWeights> &vertexWeights,
const std::vector<float> &resultValues,
bool isElementNodalResult,
const RigFemPart* femPart,
const cvf::ScalarMapper* mapper);
cvf::ref<RivIntersectionHexGridInterface> createHexGridInterface();
private:

10
ApplicationCode/ModelVisualization/Intersections/RivIntersectionGeometryGenerator.cpp
View File

@ -383,14 +383,10 @@ const std::vector<RivIntersectionVertexWeights>& RivIntersectionGeometryGenerato
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Mat3f RivIntersectionGeometryGenerator::calculateTriangleOrientation(int triangleIndex)
const cvf::Vec3fArray* RivIntersectionGeometryGenerator::triangleVxes() const
{
int triVxStartIdx = triangleIndex*3;
cvf::Vec3f p0 = m_triangleVxes->get(triVxStartIdx);
cvf::Vec3f p1 = m_triangleVxes->get(triVxStartIdx + 1);
cvf::Vec3f p2 = m_triangleVxes->get(triVxStartIdx + 2);
return cvf::GeometryTools::computePlaneHorizontalRotationMx(p1 - p0, p2 - p0);
CVF_ASSERT(m_triangleVxes->size());
return m_triangleVxes.p();
}
//--------------------------------------------------------------------------------------------------

5
ApplicationCode/ModelVisualization/Intersections/RivIntersectionGeometryGenerator.h
View File

@ -66,10 +66,9 @@ public:
// Mapping between cells and geometry
const std::vector<size_t>& triangleToCellIndex() const;
const std::vector<size_t>& triangleToCellIndex() const;
const std::vector<RivIntersectionVertexWeights>& triangleVxToCellCornerInterpolationWeights() const;
cvf::Mat3f calculateTriangleOrientation(int triangleIndex);
const cvf::Vec3fArray* triangleVxes() const;
const RimIntersection* crossSection() const;

14
ApplicationCode/ModelVisualization/Intersections/RivIntersectionPartMgr.cpp
View File

@ -51,6 +51,7 @@
#include "cvfRenderStateDepth.h"
#include "cvfRenderStatePoint.h"
#include "cafTensor3.h"
#include "cvfGeometryTools.h"
//--------------------------------------------------------------------------------------------------
@ -184,8 +185,10 @@ void RivIntersectionPartMgr::updateCellResultColor(size_t timeStepIndex)
else
{
// Special direction sensitive result calculation
// Normal, Horizontal, Semi Vertical, max shear
const cvf::Vec3fArray* triangelVxes = m_crossSectionGenerator->triangleVxes();
RivIntersectionPartMgr::calculateGeoMechTensorXfTextureCoords(m_crossSectionFacesTextureCoords.p(),
triangelVxes,
vertexWeights,
caseData,
resVarAddress,
@ -255,6 +258,7 @@ void RivIntersectionPartMgr::calculateGeoMechTextureCoords(cvf::Vec2fArray* text
///
//--------------------------------------------------------------------------------------------------
void RivIntersectionPartMgr::calculateGeoMechTensorXfTextureCoords(cvf::Vec2fArray* textureCoords,
const cvf::Vec3fArray* triangelVertices,
const std::vector<RivIntersectionVertexWeights> &vertexWeights,
RigGeoMechCaseData* caseData,
const RigFemResultAddress& resVarAddress,
@ -296,11 +300,15 @@ void RivIntersectionPartMgr::calculateGeoMechTensorXfTextureCoords(cvf::Vec2fArr
int vxCount = static_cast<int>(vertexWeights.size());
int triCount = vxCount/3;
//#pragma omp parallel for schedule(dynamic)
#pragma omp parallel for schedule(dynamic)
for (int triangleIdx = 0; triangleIdx < triCount; ++triangleIdx)
{
cvf::Mat3f triangleXf = m_crossSectionGenerator->calculateTriangleOrientation(triangleIdx);
int triangleVxStartIdx = triangleIdx*3;
cvf::Vec3f p0 = triangelVertices->get(triangleVxStartIdx);
cvf::Vec3f p1 = triangelVertices->get(triangleVxStartIdx + 1);
cvf::Vec3f p2 = triangelVertices->get(triangleVxStartIdx + 2);
cvf::Mat3f triangleXf = cvf::GeometryTools::computePlaneHorizontalRotationMx(p1 - p0, p2 - p0);
for(int triangleVxIdx = triangleVxStartIdx; triangleVxIdx < triangleVxStartIdx+3; ++triangleVxIdx)
{

16
ApplicationCode/ModelVisualization/Intersections/RivIntersectionPartMgr.h
View File

@ -68,22 +68,26 @@ private:
void computeData();
public:
static void calculateEclipseTextureCoordinates(cvf::Vec2fArray* textureCoords,
const std::vector<size_t>& triangleToCellIdxMap,
const RigResultAccessor* resultAccessor,
const cvf::ScalarMapper* mapper);
static void calculateGeoMechTextureCoords(cvf::Vec2fArray* textureCoords,
const std::vector<RivIntersectionVertexWeights> &vertexWeights,
const std::vector<float> &resultValues,
bool isElementNodalResult,
const RigFemPart* femPart,
const cvf::ScalarMapper* mapper);
void calculateGeoMechTensorXfTextureCoords(cvf::Vec2fArray* textureCoords,
const std::vector<RivIntersectionVertexWeights> &vertexWeights,
RigGeoMechCaseData* caseData,
const RigFemResultAddress& resVarAddress,
int timeStepIdx,
const cvf::ScalarMapper* mapper);
static void calculateGeoMechTensorXfTextureCoords(cvf::Vec2fArray* textureCoords,
const cvf::Vec3fArray* triangelVertices,
const std::vector<RivIntersectionVertexWeights> &vertexWeights,
RigGeoMechCaseData* caseData,
const RigFemResultAddress& resVarAddress,
int timeStepIdx,
const cvf::ScalarMapper* mapper);
cvf::ref<RivIntersectionHexGridInterface> createHexGridInterface();
private: